J'ai ces deux tableaux :

const data = [ 
  { type: 'type1', location: 23 },
  { type: 'type2', location: 37 },
  { type: 'type3', location: 61 },
  { type: 'type4', location: 67 } 
]

const com = [ 
  { name: "com1", location: 36 },
  { name: "com2", location: 60 } 
]

Et je veux tester si le locationComment dans le tableau com +1 est égal au locationMethod dans le tableau data, si oui, je veux avoir quelque chose comme ça :

const array = [
 {type: 'type2', name: "com1"},
 {type: 'type3', name: "com2"}
]

Voici mon code:

const result = data.map((x)=>{
  const arr = [];
  com.map((y)=>{
    if(x.location == y.location+1){
      arr.push({
        type: x.type,
        name: y.name,
        location: x.location
      })
    }
  })
  return arr;
});

Voici la sortie que j'obtiens:

[ [],
  [ { type: 'type2', name: 'com1', location: 37 } ],
  [ { type: 'type3', name: 'com2', location: 61 } ],
  [] ]
1
brxnzaz 16 mars 2019 à 03:53

2 réponses

Meilleure réponse

Parce que vous n'êtes pas sûr qu'il y aura une correspondance pour chaque élément du tableau com, vous devez utiliser reduce :

const data = [ 
  { type: 'type1', location: 23 },
  { type: 'type2', location: 37 },
  { type: 'type3', location: 61 },
  { type: 'type4', location: 67 } 
];

const com = [ 
  { name: "com1", location: 36 },
  { name: "com2", location: 60 } 
];

const output = com.reduce((a, { name, location }) => {
  const found = data.find(item => item.location === location + 1);
  if (found) {
    a.push({ type: found.type, name });
  }
  return a;
}, []);
console.log(output);

Si les location sont uniques, vous pouvez réduire la complexité temporelle à O(N) en transformant d'abord data en un objet indexé par location :

const data = [ 
  { type: 'type1', location: 23 },
  { type: 'type2', location: 37 },
  { type: 'type3', location: 61 },
  { type: 'type4', location: 67 } 
];

const com = [ 
  { name: "com1", location: 36 },
  { name: "com2", location: 60 } 
];

const dataByLoc = data.reduce((a, item) => {
  a[item.location] = item;
  return a;
}, {});

const output = com.reduce((a, { name, location }) => {
  const found = dataByLoc[location + 1];
  if (found) {
    a.push({ type: found.type, name });
  }
  return a;
}, []);
console.log(output);
2
CertainPerformance 16 mars 2019 à 00:56

Si la solution en une ligne ne vous intéresse pas, le code suivant devrait également fonctionner en utilisant une combinaison de .map() et .find() .

const data = [ 
  { type: 'type1', location: 23 },
  { type: 'type2', location: 37 },
  { type: 'type3', location: 61 },
  { type: 'type4', location: 67 } 
]

const com = [ 
  { name: "com1", location: 36 },
  { name: "com2", location: 60 } 
]

// Final Array Output with merged properties
let finalArr = []

data.forEach(locationMethodObj => {

// Fetching the type
let finalObj = {
type: locationMethodObj.type
}

// Checking if a location match exists 
const foundObj = com.find(locationCommentObj => (locationCommentObj.location + 1) === 
locationMethodObj.location 
)

// If a match is found, then append name and push
if(foundObj){
finalObj.name = foundObj.name
finalArr.push(finalObj)
}
})

console.log(finalArr)
1
Jibin Joseph 16 mars 2019 à 10:10