仅使用纯函数反转对象

时间:2015-01-18 11:57:22

标签: javascript functional-programming persistence immutability

假设您有一个这样的对象:

{
  a: [1,2,3],
  b: [2],
  c: [1,4]
}

您需要将其转换为:

{
  1: ['a', 'c'],
  2: ['a', 'b'],
  3: ['a'],
  4: ['c']
}

使用命令式方法和可变数据结构来执行此操作非常简单:

function convert (obj) {
  var key, values
    , result = {};

  for (key in obj) {
    values = obj[key];
    values.forEach(function (value) {
      result[value] = result[value] || []; // bad — mutability :(
      result[value].push(key); // bad — mutability :(
    });
  }

  return result;
}

但有没有办法只使用纯函数而不使用任何赋值? 允许使用某些库进行函数式编程。

3 个答案:

答案 0 :(得分:4)

好吧,它是一个纯数据转换,所以你绝对可以不使用可变变量。让我们在Haskell中做到这一点,它为我们提供了一个静态保证,即没有明确的突变。我们从一个例子开始:

d :: [(Char, [Integer])]
d = [('a', [1,2,3]), ('b', [2]), ('c', [1,4])]

好的,那么新结构的关键是什么?它们是第一个结构的独特元素:

> import Data.List
> let keys = sort . nub . concatMap snd $ d
[1,2,3,4]

然后我们需要知道每个值出现在哪一列。因此,将每个值与其键配对:

> let pairs = concatMap (\(k,v) -> map (,k) v) d
[(1,'a'),(2,'a'),(3,'a'),(2,'b'),(1,'c'),(4,'c')]

现在我们可以建立结果:

 > [ (k, map snd . filter ((== k) . fst) $ pairs ) | k <- keys ]
 [(1,"ac"),(2,"ab"),(3,"a"),(4,"c")]

充满荣耀:

{-# LANGUAGE TupleSections #-}

import Data.List

rotate d = [ (k, map snd . filter ((== k) . fst) $ pairs ) | k <- keys ]
    where
        keys  = sort . nub . concatMap snd $ d
        pairs = concatMap (\(k,v) -> map (,k) v) d

E.g。

*A> rotate [('a', [1,2,3]), ('b', [2]), ('c', [1,4])]
[(1,"ac"),(2,"ab"),(3,"a"),(4,"c")]

或者没有命名中间结构的无点版本:

rotate2  = map (\x -> (head (map fst x), map snd x))
         . groupBy ((==) `on` fst)
         . sortBy (comparing fst)
         . concatMap (\(k,v) -> map (,k) v)

好的小面试问题:)

答案 1 :(得分:1)

使用Ramda库找到了一种方法:

compose(
  reduce(function(acc, key) {
    return assoc(key, filter(compose(contains(key), propOf(src)), keys(src)), acc);
  }, {}),
  uniq,
  flatten,
  values
)(src)

答案 2 :(得分:0)

给定像Haskell的Data.Map这样的关联数据结构,我会通过为每对(v, ks) :: (String, [Int])创建几个仅包含k |-> [v]的映射来写这个(即每个键映射到一个单例)包含唯一值的列表)然后合并它们。

保持Haskell语法,这样就可以得到像

这样的东西
import qualified Data.Map as Map

insideOut :: (Ord k) => [(v, [k])] -> [(k, [v])]
insideOut vks = Map.toList . Map.unionsWith (++) $
                [ Map.singleton k [v] | (v, ks) <- vks, k <- ks]