J'ai ce tableau de données

[{"id":1, "start":"2018-10-10", "end":"2018-11-10"},
 {"id":1, "start":"2018-11-10", "end":"2018-12-10"},
 {"id":2, "start":"2018-11-22", "end":"2018-11-30"}]

Je voulais obtenir le minimum au début et le maximum à la fin.

Ma sortie souhaitée serait

{"id":1, "start":"2018-10-10", "end":"2018-12-10"},
{"id":2, "start":"2018-11-22", "end":"2018-11-30"}

J'ai essayé de faire comme ça:

data.sort((a,b) => a.start.toString().localeCompare(b.start))
-2
sad saddest 20 nov. 2018 à 11:27

4 réponses

Meilleure réponse

Ce que vous essayez de faire nécessite une solution personnalisée dans laquelle vous fusionnez deux entrées. Dans la fonction ci-dessous, j'ai itéré votre tableau en morceaux du même identifiant d'abord, je l'ai trié en fonction de l'identifiant et gardé un minimum et un maximum de l'index où votre logique dit à la date

function groupById(arr){
  arr.sort((a,b)=>a.id-b.id);
  let arrNew = [];
  let min=0, max=0, currentid = arr[0].id;
  for(i=1; i<arr.length+1;i++){
    if(!arr[i] || arr[i].id!=currentid){
      arrNew.push({id:currentid, start:arr[min].start, end: arr[max].end});
      min = i;max=i;currentid=(arr[i]||{}).id;
    }
    if(!arr[i]){
      break;
    }
    if(arr[i].start<arr[min].start){
      min = i;
    }
    if(arr[i].end>arr[max].end){
      max = i;
    }
  }
  return arrNew;
}

var result = groupById([
  {"id":1, "start":"2018-10-10", "end":"2018-11-10"},
  {"id":1, "start":"2018-11-10", "end":"2018-12-10"},
  {"id":2, "start":"2018-11-22", "end":"2018-11-30"}
]);

console.log(result);
1
joyBlanks 20 nov. 2018 à 08:48

Vous devez trier le tableau à l'aide de la comparaison de dates et également réduire par id.

var data = [{
    "id": 1,
    "start": "2018-10-10",
    "end": "2018-11-10"
  },
  {
    "id": 1,
    "start": "2018-11-10",
    "end": "2018-12-10"
  },
  {
    "id": 2,
    "start": "2018-11-22",
    "end": "2018-11-30"
  }
];


let result = data.sort((a, b) => new Date(a.start) > new Date(b.start)).reduce(function(r, a) {
  if (!r[a.id] || r[a.id][0].id !== a.id) {
    r[a.id] = r[a.id] || [];
    r[a.id].push(a);
  }

  return r;
}, Object.create(null));

console.log(result)
0
dganenco 20 nov. 2018 à 08:49

Vous pouvez utiliser la fonction réduire et vérifier la date de début et de fin et si la date de début

let old = [{
    "id": 1,
    "start": "2018-10-10",
    "end": "2018-11-10"
  },
  {
    "id": 1,
    "start": "2018-11-10",
    "end": "2018-12-10"
  },
  {
    "id": 2,
    "start": "2018-11-22",
    "end": "2018-11-30"
  }
];

let k = old.reduce(function(acc, curr) {
  let findId = acc.findIndex((item) => {
    return item.id === curr.id
  });

  if (findId === -1) {
    acc.push(curr)
  } else {
    let oldStartDate = createDate(acc[findId].start);
    let newStartDate = createDate(curr.start);
    let oldEndDate = createDate(acc[findId].end);
    let newEndDate = createDate(curr.end);


    if (newStartDate < oldStartDate) {

      acc[findId].start = curr.start
    }
    if (newEndDate > oldEndDate) {

      acc[findId].end = curr.end
    }

  }

  return acc;

}, []);

console.log(k);

function createDate(dte) {
  let dt = new Date(dte);
  return `${dt.getYear()}-${dt.getMonth()}-${dt.getDate()}`

}
0
brk 20 nov. 2018 à 09:09

Vous semblez avoir plusieurs choses qui doivent être regroupées et réduites (comme le montre le commentaire se référant à une autre question). Je vais donc fournir quelques méthodes générales dans cette réponse.

MDN possède une excellente documentation sur toutes les méthodes utilisées ici comme map, réduire et Object.value, je Je vous conseille d'y jeter un œil pour mieux comprendre le code.

La syntaxe ES6 est très bien expliquée ici

const data = [
  { id: 1, start: '2018-10-10', end: '2018-11-10' },
  { id: 1, start: '2018-11-10', end: '2018-12-10' },
  { id: 2, start: '2018-11-22', end: '2018-11-30' },
];

const groupBy = (arr, key) =>
  arr.reduce(
    (result, item) => (
      result[item[key]].push(item), result
    ),
    arr.reduce(
      (result, item) => ((result[item[key]] = []), result),
      {},
    ),
  );
const returnLowHigh = (comp) => (a, b) =>
  a.localeCompare(b) === comp ? a : b;
const lowest = returnLowHigh(-1);
const highest = returnLowHigh(1);
console.log(
  Object.values(groupBy(data, 'id')).map((items) =>
    items.reduce((result, { id, start, end }) => ({
      id,
      start: lowest(result.start, start),
      end: highest(result.end, end),
    })),
  ),
);
0
HMR 20 nov. 2018 à 09:04