2
votes

Laquelle de ces utilisations des fonctions ArrayToMap est la meilleure en termes de performances?

Vous essayez de mapper un tableau, laquelle de ces implémentations est la meilleure en termes de performances? Y a-t-il une meilleure solution?

//Given the following Array of people:
const people = [ { name: 'Alice', available: true },  { name: 'Bob', available: false }, { name: 'Charlie', available: true }];

const mapWithReduce = (people) => people.reduce((map, person) => ({ [person.name]: person.available, ...map }), {});

const mapWithForEach = (people) => {
    const map = {};
    people.forEach((person) => map[person.name] = person.available);
    return map;
}

Je trouve mapWithReduce plus jolie mais je ne sais pas si ... map} copie le mappez chaque itération. mapWithForEach semble plus performant.

javascript performance time-complexity

4 commentaires

Copie possible de Comment mesurer le temps mis par une fonction pour exécuter

@IslamElshobokshy Je ne cherche pas seulement des nombres mais aussi une explication de ce que fait ... map dans le réducteur et pour chercher d'autres implémentations

@ J.Nicastro la syntaxe de propagation de l'objet ... map copie en effet la carte cumulative à chaque itération.

@PatrickRoberts l'a compris! Merci Patrick!

3 Réponses :

1
votes

ils devraient tous les deux être identiques si vous faites les mêmes implémentations et réduire est un peu plus facile à utiliser car les développeurs savent qu'il a un accumulateur alors que dans forEach, vous implémentez simplement réduire vous-même

const mapWithReduce = (people) => people.reduce((map, person) => 
  {
    map[person.name]: = person.available;
    return map
  }, {}
);

0 commentaires

2
votes

J'aime cette solution.

const people = [ 
  { name: 'Alice', available: true },
  { name: 'Bob', available: false },
  { name: 'Charlie', available: true }
];

const peopleMap = people.reduce((map, person) => {
  map[person.name] = person;
  return map;
}, {});

console.log(peopleMap);

Ressemble à la solution forEach mais sans créer de variables locales.

https://jsperf.com/arraymapeachreduce/9

1 commentaires

Bonne amélioration. Je suggérerais cependant d'utiliser ce test , car déclarer le tableau de personnes devrait pas être pris en compte dans le cadre de référence. Tout ce qui fait est d'ajouter un décalage constant à ops / sec pour chaque cas.

2
votes

En termes de performances, en utilisant un pour la boucle est la plus rapide.

const people = [{ name: 'Alice', available: true }, { name: 'Bob', available: false }, { name: 'Charlie', available: true }]

const mapWithForLoop = (key, value) => array => {
  const map = {}

  for (let i = 0; i < array.length; i++) {
    const entry = array[i]
    map[entry[key]] = entry[value]
  }

  return map
}

const mapPeopleWithForLoop = mapWithForLoop('name', 'available')

console.log(mapPeopleWithForLoop(people))

Le forEach () se rapproche cependant.

1 commentaires

forEach () est-il alors. Merci!