Javascript 使用ramda按多种类型收集对象列表数据

我有以下数据：

const data = [
  { state: 'state1', zone: 'zone1', length: 22 },
  { state: 'state1', zone: 'zone1', length: 10 },
  { state: 'state1', zone: 'zone2', length: 66 },
  { state: 'state2', zone: 'zone1', length: 122 },
  { state: 'state2', zone: 'zone2', length: 32 },
  { state: 'state1', zone: 'zone2', length: 12}
  ...
  { state: 'stateN', zone: 'zoneN', length: X },
]

我不知道状态值和区域值的数量，它可以是无限的

我想这样：

[
  { state: 'state1', data: [32, 66] },
  { state: 'state2', data: [122, 44] },
  ...
]

其中，数据以升序表示每个分区的长度之和

你有什么想法吗？

试试这个：

const数据=[
{州：'state1'，区：'zone1'，长度：22}，
{州：'state1'，区：'zone1'，长度：10}，
{州：'state1'，区：'zone2'，长度：66}，
{州：'state2'，区：'zone1'，长度：122}，
{州：'state2'，区：'zone2'，长度：32}，
{州：'state1'，区：'zone2'，长度：12}，
{州：'stateN'，区：'zoneN'，长度：5}
]
函数getAllIndex（arr，val）{//https://stackoverflow.com/questions/20798477/how-to-find-index-of-all-occurrences-of-element-in-array
var指数=[]，i=-1；
而（（i=arr.indexOf（val，i+1））！=-1）{
指数推送（i）；
}
收益指标；
}
var states=data.map（el=>el.state）
变量statesUnique=states.filter（（el，索引）=>states.indexOf（el）==index）
var索引=[]
statesUnique.forEach（el=>index.push（getAllIndexes（states，el）））
var length=index.map（el1=>el1.map（el2=>data[el2].length）.sort（））
var sortedData=statesUnique.map（（el，index）=>{return{state:el，data:length[index]}）
console.log（sortedData）

尝试以下操作：

const数据=[
{州：'state1'，区：'zone1'，长度：22}，
{州：'state1'，区：'zone1'，长度：10}，
{州：'state1'，区：'zone2'，长度：66}，
{州：'state2'，区：'zone1'，长度：122}，
{州：'state2'，区：'zone2'，长度：32}，
{州：'state1'，区：'zone2'，长度：12}，
{州：'stateN'，区：'zoneN'，长度：5}
]
函数getAllIndex（arr，val）{//https://stackoverflow.com/questions/20798477/how-to-find-index-of-all-occurrences-of-element-in-array
var指数=[]，i=-1；
而（（i=arr.indexOf（val，i+1））！=-1）{
指数推送（i）；
}
收益指标；
}
var states=data.map（el=>el.state）
变量statesUnique=states.filter（（el，索引）=>states.indexOf（el）==index）
var索引=[]
statesUnique.forEach（el=>index.push（getAllIndexes（states，el）））
var length=index.map（el1=>el1.map（el2=>data[el2].length）.sort（））
var sortedData=statesUnique.map（（el，index）=>{return{state:el，data:length[index]}）
console.log（sortedData）

更新 奥里德罗里指出，我一步一步地错过了小组赛。这使得代码有点长，但仍然相对清晰：

const extract=管道(
groupBy（prop（“state”），
地图（分组依据（道具（‘区域’）），
地图（地图（弹拨（‘长度’）），
map（map（sum）），
映射（值），
托帕尔斯，
地图（zipObj（['state'，'levels']））
)
const data=[{state:'state1'，zone1'，长度：22}，{state:'state1'，zone1'，长度：10}，{state:'state1'，zone2'，长度：66}，{state:'state2'，zone1'，长度：122}，{state:'state2'，zone2'，长度：32}，{state:'state1 zone1'，zone2'，长度：12}，/*/*/{state:'state:'stateN'，zone2'，zone2'，zone2'，zoneN'，zoneN'，zoneN'，zoneN'
console.log（提取（数据））

const{pipe，groupBy，prop，map，pull，sum，values，toPairs，zipObj}=R

Update 奥里德罗里指出，我一步一步地错过了小组赛。这使得代码有点长，但仍然相对清晰：

const extract=管道(
groupBy（prop（“state”），
地图（分组依据（道具（‘区域’）），
地图（地图（弹拨（‘长度’）），
map（map（sum）），
映射（值），
托帕尔斯，
地图（zipObj（['state'，'levels']））
)
const data=[{state:'state1'，zone1'，长度：22}，{state:'state1'，zone1'，长度：10}，{state:'state1'，zone2'，长度：66}，{state:'state2'，zone1'，长度：122}，{state:'state2'，zone2'，长度：32}，{state:'state1 zone1'，zone2'，长度：12}，/*/*/{state:'state:'stateN'，zone2'，zone2'，zone2'，zoneN'，zoneN'，zoneN'，zoneN'
console.log（提取（数据））

const{pipe，groupBy，prop，map，pulk，sum，values，toPairs，zipObj}=R

按

状态对每个组进行分组，并映射每个组，并对其应用规范。使用
R.mapObjIndexed
时，状态是第二个参数（键）。
数据
要求按照
区域
对州组中的项目进行分组，并对
长度
求和


const{pipe、groupBy、prop、map、pull、sum、value、sort、mapObjIndexed、applySpec、nthArg、subtract}=R
const sumZones=管道(
groupBy（prop（'zone'），//按分区分组
映射（pipe（pull（'length'），sum）），//对每个分区中的结果求和
值，//转换为值数组
排序（减法）//根据需要对项目进行排序
)
常数fn=管道(
groupBy（prop（'state'），//按state prop分组
mapObjIndexed（applySpec（{//将每个组转换为一个对象
state:nthArg（1），//从第二个arg-索引1中获取该州的名称
数据：sumZones//求每个状态下分区的长度之和
})),
值，//将对象对象转换为对象数组
)
const data=[{state:'state1'，zone1'，length:22}，{state:'state1'，zone1'，length:10}，{state:'state1'，zone2'，zone1'，length:122}，{state:'state2'，zone2'，zone2'，length:32}，{state:'state1 zone1'，zone2'，length:12}，/*/*/{state:'state:'state'，zone2'，zone2'，zone2'，zone2'，zoneN'，zoneN'，zoneN'，zoneN'，len
常数结果=fn（数据）
console.log（结果）
。作为控制台包装器{
最大高度：100%！重要；
排名：0
}
按
状态分组，并映射每个组，并对其应用规范。使用
R.mapObjIndexed
时，状态是第二个参数（键）。
数据
要求按照
区域
对州组中的项目进行分组，并对
长度
求和


const{pipe、groupBy、prop、map、pull、sum、value、sort、mapObjIndexed、applySpec、nthArg、subtract}=R
const sumZones=管道(
群比（道具）(
const getLengthSumOnEachZoneByState = R.pipe(
  R.groupBy(R.prop('state')),
  R.map(
   R.pipe(
    R.sortBy(R.prop('zone')),
    R.groupBy(R.prop('zone')),
    R.map(R.pipe(R.pluck('length'), R.sum)),
    R.values
   )
  )
)

console.log(getLengthSumOnEachZoneByState(data)) // <====== Result

const zonesByState = data.reduce((zonesByState, zone) => {
  if (zonesByState[zone.state] == null) {
    zonesByState[zone.state] = []
  }
  zonesByState[zone.state].push(zone)
  return zonesByState
}, {})
​
const stateLengths = Object.entries(zonesByState)
  .map(([state, zones]) => {
    const lengthsByZone = zones.reduce((lengthsByZone, zone) => {
      if (lengthsByZone[zone.zone] == null) {
        lengthsByZone[zone.zone] = 0
      }
      lengthsByZone[zone.zone] += zone.length
      return lengthsByZone
    }, {})
    return {
      state,
      data: Object.values(lengthsByZone).sort()
    }
  })
  console.log(stateLengths) // <====== Result