Question

我接受了挑战并且已经做了，但是我认为这不是一个好方法。我认为做同一件事有很短的路要走。

我正在寻找MAP，REDUCE和FILTERS，但找不到一种好方法。

目标是：

查找重复的交易。
类似的人
排序结果

说明：有时，当向客户收费时，会创建重复的交易。我们需要找到那些交易，以便可以对其进行处理。交易的所有内容均应相同，但交易ID和发生的时间除外，因为可能会延迟一分钟。

findDuplicateTransactions（transactions）

查找具有相同sourceAccount，targetAccount，类别，金额且每次连续事务之间的时间差小于1分钟的所有事务。

输入您可以假设所有参数将始终存在且有效。但是，不能保证传入的事务按任何特定顺序进行。

交易清单（交易[]）输出所有重复事务组的列表，按时间升序排列（Transaction [] []）。应按组中第一个事务的升序对组进行排序。例输入：

[
  {
    id: 3,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:34:30.000Z'
  },
  {
    id: 1,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:33:00.000Z'
  },
  {
    id: 6,
    sourceAccount: 'A',
    targetAccount: 'C',
    amount: 250,
    category: 'other',
    time: '2018-03-02T10:33:05.000Z'
  },
  {
    id: 4,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:36:00.000Z'
  },
  {
    id: 2,
    sourceAccount: 'A',
    targetAccount: 'B',
    amount: 100,
    category: 'eating_out',
    time: '2018-03-02T10:33:50.000Z'
  },
  {
    id: 5,
    sourceAccount: 'A',
    targetAccount: 'C',
    amount: 250,
    category: 'other',
    time: '2018-03-02T10:33:00.000Z'
  }
];

预期输出：

[
  [
    {
      id: 1,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:33:00.000Z"
    },
    {
      id: 2,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:33:50.000Z"
    },
    {
      id: 3,
      sourceAccount: "A",
      targetAccount: "B",
      amount: 100,
      category: "eating_out",
      time: "2018-03-02T10:34:30.000Z"
    }
  ],
  [
    {
      id: 5,
      sourceAccount: "A",
      targetAccount: "C",
      amount: 250,
      category: "other",
      time: "2018-03-02T10:33:00.000Z"
    },
    {
      id: 6,
      sourceAccount: "A",
      targetAccount: "C",
      amount: 250,
      category: "other",
      time: "2018-03-02T10:33:05.000Z"
    }
  ]
];

这是我的代码，但我不喜欢它。有一些不错的方法吗？

function findDuplicateTransactions (transactions = []) {
    var result = [];

    console.info("total itens :" + transactions.length);

      //sort
      transactions = transactions.sort((a,b)=> a.time.localeCompare(b.time))

      //remove itens not duplicated
      result = removeItens(transactions);


      //group
      result = groupBy(result, function(item){
          return [item.sourceAccount, item.targetAccount, item.amount, item.category];
      });

  console.info(result);

      //remove UniqueElements
      result = removeUniqueElements(result);



      return result;
  }

  function removeUniqueElements(array){
      var filtered = array.filter(function(value, index, arr){
          return value.length >= 2;
      });

      return filtered;
  }

  function removeItens(array){
      var itensToBeRemoved = [];
      for (var index = 0; index < array.length; index++) {
          const element1 = array[index];
          var cont = 0;

          console.info("============== looking for: " + element1.id);

          for (var index2 = 0; index2 < array.length; index2++) {
              const element2 = array[index2];

              if(element1.id != element2.id){


                var date1 = new Date(element1.time);
                var date2 = new Date(element2.time);

                var timeDiff = Math.abs(date2.getTime() - date1.getTime());

                console.info("comparing :" + element1.id + "<->" + element2.id + " diff: " + timeDiff);


                if( timeDiff < 60000) {
                    //keep it - is similar
                    console.info("find one duplicated: " + element2.id);
                    break;
                }else{
                    cont++;
                }
              }
          }

          //console.info("cont: " + cont)

          if(cont == array.length-1){
            //array.splice(index, 1);
            console.info("possible duplicated: " + element1.id);
            itensToBeRemoved.push(element1.id);
          }
      }

      var filtered = [];

      for(var i=0; i<itensToBeRemoved.length; i++){
          console.info("remove item: " + itensToBeRemoved[i]);
          array = arrayRemove(array, itensToBeRemoved[i]);
      }

    return array;
  }

function arrayRemove(arr, value) {
   return arr.filter(function(ele){
       console.info("watching: " + ele.id);
       console.info("index: " + value);
       return ele.id != value;
   });
}

  function groupBy( array , f ){
      var lists = {};
      array.forEach( function( o ){
          var list = JSON.stringify( f(o) );
          lists[list] = lists[list] || [];
          lists[list].push( o );  
      });
      return Object.keys(lists).map( function( list ){
          return lists[list]; 
      })
  }

Answer 1

您可以预先对数组进行排序，并通过查找具有相同类别的组来缩小数组。

var data = [{ id: 3, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:34:30.000Z' }, { id: 1, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:00.000Z' }, { id: 6, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:05.000Z' }, { id: 4, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:36:00.000Z' }, { id: 2, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:50.000Z' }, { id: 5, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:00.000Z' }],
    result = data
        .sort(({ time: a }, { time: b }) => a.localeCompare(b))
        .reduce((r, o) => {
            var temp = r.find(([{ category }]) => category === o.category);
            if (!temp) r.push(temp = []);
            temp.push(o);
            return r;
        }, []);

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

带有哈希表。

const delta = (t1, t2) => Math.abs(new Date(t1) - new Date(t2));

var data = [{ id: 3, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:34:30.000Z' }, { id: 1, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:00.000Z' }, { id: 6, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:05.000Z' }, { id: 4, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:36:00.000Z' }, { id: 2, sourceAccount: 'A', targetAccount: 'B', amount: 100, category: 'eating_out', time: '2018-03-02T10:33:50.000Z' }, { id: 5, sourceAccount: 'A', targetAccount: 'C', amount: 250, category: 'other', time: '2018-03-02T10:33:00.000Z' }],
    keys = ['sourceAccount', 'targetAccount', 'amount', 'category'],
    result = Object.values(data
        .sort(({ time: a }, { time: b }) => a.localeCompare(b))
        .filter((o, i, a) => {
            while (a[--i] && delta(o.time, a[i].time) < 60000) {
                if (keys.every(k => o[k] === a[i][k])) return;
            }
            return true;
        })
        .reduce((r, o) => ((r[o.category] = r[o.category] || []).push(o), r), {})
    );

console.log(result);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

您可以先根据时间排序，然后减少

let data =  [{id: 3,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:34:30.000Z'},{id: 1,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:33:00.000Z'},
{id: 6,sourceAccount: 'A',targetAccount: 'C',amount: 250,category: 'other',time: '2018-03-02T10:33:05.000Z'},
{id: 4,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:36:00.000Z'},
{id: 2,sourceAccount: 'A',targetAccount: 'B',amount: 100,category: 'eating_out',time: '2018-03-02T10:33:50.000Z'},{id: 5,sourceAccount: 'A',targetAccount: 'C',amount: 250,category: 'other',time: '2018-03-02T10:33:00.000Z'}];

let sortedData = data.sort((a,b)=> a.time.localeCompare(b.time))

let keyTrack = sortedData[0].sourceAccount + sortedData[0].targetAccount
let temp = []
let final = sortedData.reduce((op,inp) => {
  let key = inp.sourceAccount + inp.targetAccount
  if(keyTrack !== key){
    keyTrack = key
    op.push(temp)
    temp = []
  }
  temp.push(inp)
  return op
},[])

if(temp.length){
  final.push(temp)
}

console.log(final)

Javascript-分组和排序对象

2 个答案: