主页 / 问题 / 1170613
Accepted
Pavel
Asked:2020-08-26 15:36:43 +0000 UTC2020-08-26 15:36:43 +0000 UTC

如何使代码可读？(javascript)

  • 772

let massive = [
  ["Mallory", "Everest", "Mont Blanc", "Pillar Rock"],
  ["Mawson", "South Pole", "New Hebrides"],
  ["Hillary", "Everest", "South Pole"]
];


function func(massive) {


  let toponymes = [];
  let explorers = [];
  let result = [];

  for (let i = 0; i < massive.length; i++) {
    explorers = [...explorers, massive[i][0]]
    // выписываем всех исследователей
    massive[i].map((topo) => {
      if (massive[i][0] != topo) {
        toponymes = [...toponymes, topo]
        // выписываем все топонимы
      }
    })
  }
  toponymes = [...new Set(toponymes)]; //исбавляемся от дубликатов



  toponymes.map((t, id) => {
    for (let i = 0; i < massive.length; i++) {
      massive[i].map((m) => {

        if (m == t) {

          if (result[id] === undefined) {
            result[id] = [toponymes[id], explorers[i]]
          } else {
            result[id] = [...result[id], toponymes[id], explorers[i]]
          }
          result[id] = [...new Set(result[id])];
        }
      })
    }
  })
  console.log(result)
  return (result)

}
func(massive)
总的来说，我在 JS 中解决了一个问题，其中给出了一个地点和访问过它们的人的数组，您需要回收该数组以便首先放置地点，然后是访问过它们的人。我正确地解决了这个问题，但在我看来，魔鬼会在我的解决方案中打断他的腿。实际上问题是，我的解决方案是否不好，如何使代码更易于理解？我刚刚开始弄清楚，我认为您需要立即学习如何漂亮而清晰地做到这一点。都好。

javascript

3 个回答

  1. Best Answer

    上面的代码有两部分：

    1. 分别识别独特的探险家和地名
    2. 搜索访问过地名的研究人员。

    1. 独特的研究人员和地名分别识别

    考虑第一部分：

    let toponymes = [];
let explorers = [];

for (let i = 0; i < massive.length; i++) {
  explorers = [...explorers, massive[i][0]]
  // выписываем всех исследователей
  massive[i].map((topo) => {
    if (massive[i][0] != topo) {
      toponymes = [...toponymes, topo]
      // выписываем все топонимы
    }
  })
}
toponymes = [...new Set(toponymes)]; //избавляемся от дубликатов

    这里又分为两部分。

    1. 填充explorer：在这种情况下，只需简单地使用就足够了push，无需不断复制数组，只需向其中添加一个元素

       explorers.push(massive[i][0])

    2. 填充toponymes：如果你看数组，你会注意到除了第一个元素之外的所有元素都是地名，所以检查和遍历所有元素是没有意义的，你可以立即获取除第一个元素之外的所有元素，例如，使用slice

       toponymes.push(...massive[i].slice(1));

    结果，代码可能如下所示

    let toponymes = [];
let explorers = [];

for (let i = 0; i < massive.length; i++) {
  explorers.push(massive[i][0]);
  toponymes.push(...massive[i].slice(1));
}
toponymes = [...new Set(toponymes)]; //избавляемся от дубликатов

    或者，如果我们使用解构和循环for..of，即使如此

    for (var [explore, ...toponym] of massive){
  explorers.push(explore);
  toponymes.push(...toponym);
}
toponymes = [...new Set(toponymes)]; //избавляемся от дубликатов

    2. 搜索访问过地名的研究人员。

    考虑第二部分：

    let result = [];
toponymes.map((t, id) => {
  for (let i = 0; i < massive.length; i++) {
    massive[i].map((m) => {

      if (m == t) {

        if (result[id] === undefined) {
          result[id] = [toponymes[id], explorers[i]]
        } else {
          result[id] = [...result[id], toponymes[id], explorers[i]]
        }
        result[id] = [...new Set(result[id])];
      }
    })
  }
})

    1. 引起您注意的第一件事是不正确地使用.map. 此方法允许您基于旧集合创建新集合，但在这种情况下，它用作循环for。相反，代码应该是这样的：

       let result = toponymes.map((t, id) => { ... });

    2. 映射规则很简单：每个元素t对应一个数组，以这个元素开头。

       t => [t, ...]

    3. 接下来，您需要过滤访问过该地点的研究人员列表。这可以通过多种方式完成，例如

       explorers.filter((explorer, index) => massive[index].some(el => el === t));

      在这种情况下，使用该方法filter，只选择那些访问过该地点的研究人员t。explorers 数组中元素的顺序对应于海量的顺序，因此选择一个数组来检查位置归结为通过索引获取元素。

    因此，代码采用以下形式：

    let result = toponymes.map((t, id) => [t, ...explorers.filter((explorer, index) => massive[index].some(el => el === t))]);

    组装示例：

    let massive = [
  ["Mallory", "Everest", "Mont Blanc", "Pillar Rock"],
  ["Mawson", "South Pole", "New Hebrides"],
  ["Hillary", "Everest", "South Pole"]
];

function fun(massive) {
  let toponymes = [];
  let explorers = [];

  for (var [explore, ...toponym] of massive) {
    explorers.push(explore);
    toponymes.push(...toponym);
  }
  toponymes = [...new Set(toponymes)]; //избавляемся от дубликатов

  let result = toponymes.map((t, id) => [t, ...explorers.filter((explorer, index) => massive[index].some(el => el === t))]);

  return result;
}

console.log(fun(massive));
    .as-console-wrapper {
  max-height: 100% !important;
}

    另一种解决方案可能是一种方法，将数组一次性折叠成一个对象，其中包含地名和值的键 - 人员列表。对于卷积，它使用.reduce

    let massive = [
  ["Mallory", "Everest", "Mont Blanc", "Pillar Rock"],
  ["Mawson", "South Pole", "New Hebrides"],
  ["Hillary", "Everest", "South Pole"]
];


function a(data) {
  return Object.values( // получаем результат
    data.reduce( // бежим по всем элементам
      (acc, [people, ...places]) => // собираем результат в acc, в people хранится человек, в places - список мест
      places.reduce( // сворачиваем список мест в объект
        (res, place) => ({ ...res,
          [place]: (res[place] || [place]).concat(people) // если соответствующего поля не было - сохраняем в нем 'место', если было - добавляем человека.
        }),
        acc), {}));
}

console.log(a(massive));
    .as-console-wrapper {
  max-height: 100% !important;
}

    • 7

  2. 当然，这完全是口味问题......如果目标是可读性，目前我会这样做：

    let data = [
  ["Mallory", "Everest", "Mont Blanc", "Pillar Rock"],
  ["Mawson", "South Pole", "New Hebrides"],
  ["Hillary", "Everest", "South Pole"]
];

console.log( peopleInPlaces(data) );

/***/
function peopleInPlaces(data) {
  /*  data = [
   *    [person1, place1, place2...],
   *    [person2, place1, place2...],
   *    ...
   * 
   *  result = [
   *    [place1, person1, person2],
   *    [place2, person1, ...]
   */
   
   let places = {};
   
   for (let arr of data) {
     arrangePeople(arr);
   }
   
   return arrFromPlaces(places);
   
   /***/
   function arrangePeople([person, ...arr]) {
     // [person, place1, place2, ...]
     
     for (let place of arr) {
       if (!places[place]) places[place] = [];
       
       places[place].push(person);
     }
   }
   
   function arrFromPlaces(obj) {
     /* obj = {
      *   place1: [person1, person2],
      *   place2: [...]
      */
      
      return Object.entries(obj).map( ([place, persons]) => [place].concat(persons) );
   }
}

    那些。如果该函数适用于数据，首先我至少要注意它是什么类型的数据——这样我就不必每次都爬上去看看它来自哪里以及它包含什么。在主要功能中 - 也是预期的结果。

    Ps 同时，Object.entries() - 一个循环，map() - 第二个循环，concat() - 第三个循环，+解构的成本[地点，人员]。

    在实际代码中，您还需要考虑大数据是如何到达的，以及从什么时候开始切换到更优化的变体。混淆的精灵代码总是可以用注释来补偿。

    • 4 

  3. let massive = [
  ["Mallory", "Everest", "Mont Blanc", "Pillar Rock"],
  ["Mawson", "South Pole", "New Hebrides"],
  ["Hillary", "Everest", "South Pole"]
];

let result = massive.reduce((acc, item) => {
  for (let i = 1; i < item.length; i++) {
    let found = acc.find(it => it[0] == item[i]);
    found? found.push(item[0]) : acc.push([item[i], item[0]]);
  }
  return acc;
}, []);

console.log(result);

    • 3

相关问题