Javascript coffeescript-操作json

这只是逻辑问题，如果我有数据：

    [
        {
            from: 'user a',
            to: 'user b'
        },
        {
            from: 'user a',
            to: 'user c'
        },
        {
            from: 'user b',
            to: 'user d'
        },
        {
            from: 'user c',
            to: 'user d'
        },
        {
            from: 'user c',
            to: 'user d'
        }
    ]

我需要处理这些数据，以便：

    [
        {
            from: 'user a',
            to: ['user b', 'user c']
        },
        {
            from: 'user b',
            to: ['user d']
        },
        {
            from: 'user c',
            to: ['user d']
        }
    ]

我使用了以下代码：

    result = []
    objTemp = obj
    from = []       
    obj.map (o) ->
        if o.from not in from
            from.push o.from
            to = []
            objTemp.map (oo) ->
                if oo.from is o.from and oo.to not in to
                    to.push oo.to
            temp =
                from: o.from
                to: to
            result.push temp

但结果并不是我所期望的，在相同的“from”中仍然有相同的“to”：

   [
        {
            from: 'user a',
            to: ['user b', 'user c']
        },
        {
            from: 'user b',
            to: ['user d']
        },
        {
            from: 'user c',
            to: ['user d', 'user d'] <-- the problem
        }
    ]

[
{
发件人：'用户a'，
收件人：[‘用户b’、‘用户c’]
},
{
发件人：'用户b'，
收件人：['user d']
},
{
from:'用户c'，
收件人：['user d'，'user d']以下是我的做法：

res = []
obj.map (o) ->
  for r in res when r.from is o.from
    return (r.to.push o.to unless o.to in r.to)
  res.push from: o.from, to: [o.to]

为了方便使用
groupBy
和
uniq
方法（以及
chain
），我可能会使用下划线或lowdish。如果您对实现它们感兴趣，以便在生咖啡脚本中实现，您可以查看带注释的源代码


chain
/
value
只允许我内联调用这些函数，而不是使用临时变量来保存它们或使函数调用不那么明显

fromUser = (x)-> x.from

toRelationships = (memo, items, index, list)->
  key = _(items).pluck('from')[0]
  vals = _.values(list[key])
  memo[key] = _(vals).chain().pluck('to').uniq().value()
  memo

result = _(data).chain().groupBy(fromUser).reduce(toRelationships, []).value()

# without chain
grouped = _(data).groupBy( fromUser )
result = _(grouped).reduce( toRelationships, [])

jsfiddle:
这是我的观点，我很抱歉没有像我希望的那样简洁。如果我使用jQuery（或其他第三方），这会更简单一些，但这里没有任何库

a =     [
        {
            from: 'user a',
            to: 'user b'
        },
        {
            from: 'user a',
            to: 'user c'
        },
        {
            from: 'user b',
            to: 'user d'
        },
        {
            from: 'user c',
            to: 'user d'
        },
        {
            from: 'user c',
            to: 'user d'
        }
    ]
c = {}
d = []
(value for value in a).forEach (v) -> 
     c[v.from] = do -> if not c[v.from] then [v.to] else ("#{c[v.from]},#{v.to}").
         split(',').reduce ((p,c) -> 
             if c not in p then p.concat([c]) else [c] ), [] 

d.push {'from':v,'to':k} for v,k of c

console.log d

当您必须在map函数之外声明数组时，您知道您使用map是错误的。我可以建议reduce吗？@JedSchneider，我相信您是对的。但是您的小提琴有一个小问题，它返回重复的条目。如果我尝试在
for
循环中
返回
，它会抛出一个错误。您如何处理？抱歉@multi我没有为准确性进行调试，只是向您展示了如何使用您的方法传递数组以减少。我可以更深入地查看它并提供答案。我没有意识到它呈现了不准确的结果。使用我自己的答案进行了更新。要回答您的问题，您需要统一结果。