nesneyi lodash ile diziye dönüştür

Nasıl ben büyük dönüştürebilir objectiçin arraylodash ile?

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

Yapabilirsin

var arr = _.values(obj);

Dokümantasyon için buraya bakınız .

_.toArray(obj);

Çıkışlar:

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

Eğer ilgilenen varsa modern bir yerli çözüm:

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

veya (IE değil):

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

Benim için bu işe yaradı:

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

Döner

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

içine

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

Sonucunu almak için birkaç yol var. Onları kategorilere ayıralım:

Yalnızca ES6 Değerleri :

Bunun ana yöntemi Object.values . Ancak Object.keys ve Array.map kullanarak beklenen sonuca ulaşabilirsiniz:

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 Anahtar ve Değer :

Map ve ES6 dinamik / hesaplanmış özellikleri ve yıkımı kullanarak anahtarı tutabilir ve bir nesneyi haritadan döndürebilirsiniz.

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
})))

Yalnızca Lodash Değerleri :

_.valuesAncak bunun için tasarlanan yöntem "kısayollar" gibi _.mapve sadece nesneden değerleri_.toArray içeren bir dizi döndürecek yarar yöntemi vardır . Yapabilirsin da olsa ve kullanarak nesneden değerleri almak gösterimi._.map_.keysobj[key]

Not: _.mapBir nesne iletildiğinde baseMap, temel forEacholarak nesne özellikleri üzerinde bulunan işleyicisini kullanır .

_.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 Anahtar ve Değeri :

// 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>

Yukarıdaki örneklerde ES6'nın kullanıldığını unutmayın (ok işlevleri ve dinamik özellikler). ES6 _.fromPairsbir sorunsa, nesne oluşturmak için lodash ve diğer yöntemleri kullanabilirsiniz.

Anahtarın (bu durumda id) her dizi öğesinin bir özelliği olarak korunmasını istiyorsanız, şunları yapabilirsiniz

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 güncellemesi: Object.values , lodash değerleri ve toArray bunu yapar. Ve tuşları harita korumak ve operatör oyun güzel yaymak için :

// 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>

Nesneyi düz JavaScript'lerle diziye dönüştürme ( 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);

Ayrıca anahtarları kullanmak Object.entriesve Array#mapbu şekilde tutmak istiyorsanız :

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)

_.mapFonksiyonu (her ikisinin lodashve underscore) işlevini de kullanabilirsiniz object, bu durumu dahili olarak işleyecek, her değer ve anahtarı yinelemenizle yineleyecek ve son olarak bir dizi döndürecektir. Infact, _.map(obj)sadece bir değer dizisi istiyorsanız , herhangi bir yineleme olmadan kullanabilirsiniz (sadece ). İyi yanı, arada herhangi bir dönüşüme ihtiyacınız varsa, bunu bir seferde yapabilirsiniz.

Misal:

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>

Ancak, nesnenizi dönüştürmek istiyorsanız, bunu korumanız gerekir, anahtarı korumanız gerekse bile, bunu ( _.map(obj, (v, k) => {...}) ek argüman ile yapabilir mapve daha sonra istediğiniz şekilde kullanabilirsiniz.

Ancak bunun için başka Vanilla JS çözümü var (her lodashçözümün saf JS sürümü olması gerektiği gibi) gibi:

• Object.keysve sonra maponları değerlere
• Object.values (ES-2017'de)
• Object.entriesve sonra mapher bir anahtar / değer çifti (ES-2017'de)
• for...in döngü ve her tuşa değerleri atmak için kullanın

Ve çok daha fazlası. Ancak bu soru lodash(ve zaten kullanan birini varsayarak) için olduğu için , sürüm, yöntem desteği ve bulunmazsa hata işleme hakkında çok fazla düşünmenize gerek yoktur.

_.values(Belirli bir amaç için daha okunabilir) veya çiftler alıp daha sonra harita vb. Gibi diğer lodash çözümleri vardır . ancak kodunuzun keysdeğerleri biraz korumanız veya dönüştürmeniz gerektiğinde gelecekte güncelleyebileceğiniz esnekliğe ihtiyaç duyması durumunda , en iyi çözüm _.mapbu cevabı addresed olarak bir tekli kullanmaktır . Bu okunabilirliğe göre o kadar da zor olmayacak.

Diziye Nesne

Tüm cevaplar arasında bunun en iyisi olduğunu düşünüyorum:

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

dönüştüren:

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

için:

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

Nesne Dizisi

Geri dönüşümü yapmak için:

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

Anahtarı değerde tutarak geri dönüştürmek için:

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

Verecek:

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

Son örnek için ayrıca lodash _.keyBy(arr, 'key')veya kullanabilirsiniz _.keyBy(arr, i => i.key).

Object'in bir Array ile bazı özel eşlemesini (orijinal Array.prototype.map gibi) istiyorsanız, şunu kullanabilirsiniz _.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 belgesine bakın https://lodash.com/docs/#forEach