基于事件次数的数组排序

Question

有人能解释一下这段代码中发生了什么吗？

问题

根据元素出现的次数按降序排序数组

示例输入：

let chocoArr= ["red", "blue", "green", "red"];

示例输出：

["red", "red", "blue", "green"]

码

​

let chocoArr = ["red", "blue", "green", "red"];

const sortChocolateBasedOnCount = (chocolates) => {
  let cho = chocolates.reduce(function(temp1, temp2) {
    if (temp2 in temp1) {
      temp1[temp2]++;
    } else {
      temp1[temp2] = 1;
    }
    return temp1;
  }, {});
  let Array = chocolates.sort((temp1, temp2) => {
    if (cho[temp2] > cho[temp1]) {
      return 1;
    }
    if (cho[temp2] < cho[temp1]) {
      return -1;
    }
    if (temp1 > temp2) {
      return 1;
    }
    if (temp1 < temp2) {
      return -1;
    }
  });
  chocolates = Array;
}

console.log(sortChocolateBasedOnCount(chocoArr));

​

Answer 1

这段代码有一些问题。

• 的第一件事是函数sortChocolateBasedOnCount不返回一个值，在下面的代码
• 中，在sortChocolateBasedOnCount函数中，一个变量被命名为Array，这是不允许的。Array是一个保留关键字，不能用作变量名.

最初，函数sortChocolateBasedOnCount接收数组作为参数。这个数组与chocoArr相同。这个数组被简化为一个使用Array.reduce的对象。

约简函数通过输入颜色数组中的值循环。这些值作为累加器的键保存，值将是相同值的计数。循环将执行4次，因为输入数组有4项。当循环开始执行时，请查找下面的累加器初始值和当前值的列表，以及循环执行结束时存储的累加器的最终值。

如果第一次找到该键，则将该值保存为1，并且该值将增加以供进一步发生。

• Itration 1:蓄能器初始：{}，CurrentValue：red，累加器最终{ red: 1, blue: 1, green: 1 }
• Itration 2:蓄能器初始：{ red: 1 }，CurrentValue：blue，累积器最终{ red: 1, blue: 1 }
• Itration 3:蓄能器初始值：{ red: 1, blue: 1 }，CurrentValue：green，累加器最终{ red: 1, blue: 1, green: 1 }
• Itration 4：E 237累加器初始：{ red: 1, blue: 1, green: 1 }，：red，累加器最终{ red: 2, blue: 1, green: 1 }

>

还原函数的输出将是颜色的名称作为键，数组中的每种颜色的计数作为值。

{ red: 2, blue: 1, green: 1 }

在小提琴中找到上面的第一根木头。

您的输入数组，即颜色列表数组，将根据上述对象中的计数，根据下面的逻辑进行排序。

• 信息排序是根据reduce函数返回的每个键的值进行的。如果两个
• 都有相同的计数，则按字母顺序对最后两个If.
• 进行排序，如果不满足任何条件，则排序函数应该返回
• 。

更新代码

​

let chocoArr = ["red", "blue", "green", "red"];

const sortChocolateBasedOnCount = (chocolates) => {
  let cho = chocolates.reduce(function (temp1, temp2) {
    // temp1 holds the accumulator
    // temp2 holds the current value of array loop
    if (temp2 in temp1) {
      temp1[temp2]++;
    } else {
      temp1[temp2] = 1;
    }
    return temp1;
  }, {});
  console.log(cho);
  let sortedAray = chocolates.sort((temp1, temp2) => {
    if (cho[temp2] > cho[temp1]) {
      return 1;
    }
    if (cho[temp2] < cho[temp1]) {
      return -1;
    }
    if (temp1 > temp2) {
      return 1;
    }
    if (temp1 < temp2) {
      return -1;
    }
    return 0;
  });
  return sortedAray;
}

console.log(sortChocolateBasedOnCount(chocoArr));

​

更新一些变量名称的代码的清晰版本如下所示。

​

let chocoArr = ["red", "blue", "green", "red"];

const sortChocolateBasedOnCount = (chocolates) => {
  let reducedChocolate = chocolates.reduce(function (acc, curr) {
    if (curr in acc) {
      acc[curr]++;
    } else {
      acc[curr] = 1;
    }
    return acc;
  }, {});
  console.log(reducedChocolate);
  let sortedAray = chocolates.sort((a, b) => {
    if (reducedChocolate[b] > reducedChocolate[a]) {
      return 1;
    }
    if (reducedChocolate[b] < reducedChocolate[a]) {
      return -1;
    }
    if (a > b) {
      return 1;
    }
    if (a < b) {
      return -1;
    }
    return 0;
  });
  return sortedAray;
}
console.log(sortChocolateBasedOnCount(chocoArr));

​

Answer 2

守则的问题：

1. let Array =虽然没有错，但如果您想在函数的后面执行new Array或其他数组方法(不是实例，而是Array.from等)，它将无法工作，因为您已经用sort
2. chocolates = Array;的结果重击了Array是没有意义的，对所有
3. 都没有任何影响--函数不会对一个水果列表返回任何类似的值操作，例如，排序永远不会返回0(当两个元素相等时)，而是返回undefined尤其是对于减少，是贫穷的，至少可以说是

。

所以，修正前三个问题，以及另外两个“风格问题”。

​

let chocoArr = ["red", "blue", "green", "red"];

const sortChocolateBasedOnCount = (chocolates) => {
  let counts = chocolates.reduce(function(accumulator, choco) {
    if (choco in accumulator) {
      accumulator[choco]++;
    } else {
      accumulator[choco] = 1;
    }
    return accumulator;
  }, {});
  let result = chocolates.sort((a, b) => {
    if (counts[b] > counts[a]) {
      return 1;
    }
    if (counts[b] < counts[a]) {
      return -1;
    }
    if (a > b) {
      return 1;
    }
    if (b < a) {
      return -1;
    }
    return 0;
  });
  // important note - the incoming array WILL be sorted too
  //chocolates = result; //doesn't achieve anything
  return result;
  
}

console.log(sortChocolateBasedOnCount(chocoArr));
console.log(chocoArr);

​

但是，您可以做得更好，因为函数名有点限制性，如果您想对水果执行类似的排序，那么创建一个名为sortFruitsBasedOnCount的相同函数会怎么样？那是多余的

另外，如果你不想改变原来的数组，你也可以做一些事情。

function (temp1, temp2)和(temp1, temp2) =>的混合.为什么？如果可以的话，可以使用一种风格(而且你可以)

所以，让我们做更多的改变

​

let chocoArr = ["red", "blue", "green", "red"];

const sortOnWordCount = (words) => {
  const counts = words.reduce((acc, word) => {
    acc[word] = (acc[word] || 0) + 1;
    return acc;
  }, {});
  return [...words].sort((a, b) => {
    const diff = counts[b] - counts[a];
    if (diff) {
        return diff;
    }
    return a.localeCompare(b);
  });
}

console.log(sortOnWordCount(chocoArr).join());
console.log(chocoArr.join()); // note this is unchanged

// same function, different array
let fruitArr = ["banana", "apple", "banana", "orange"];
console.log(sortOnWordCount(fruitArr).join());

​

想象一下如果最后一行是

 sortChocolateBasedOnCount(fruitArr);

看起来会很奇怪

acc[word] = (acc[word] || 0) + 1; -原始代码中的if/else完全有效的替代方案

将[...words].sort替换为words.sort，传入的数组将与第一段代码中的情况一样发生变化

从某种意义上说，你可以返回负值、正数或零.不仅仅是-11和0

所以，const diff = counts[b] - counts[a];计算出了差异(所以我们只需要做一次counts[a]，而不是两次)。

如果不是零，就把它还回去

否则，使用字符串localeCompare方法，根据两个字符串的词法顺序返回-1、0或1.一行而不是有效的5行

如果小代码大小赢得了分数-但是仍然有有意义的函数名。

​

let chocoArr = ["red", "blue", "green", "red"];

const sortOnWordCount = (words) => {
  const counts = words.reduce((acc, word) => (acc[word] = (acc[word] || 0) + 1, acc), {});
  return [...words].sort((a, b) => (counts[b] - counts[a]) || a.localeCompare(b));
};

console.log(sortOnWordCount(chocoArr));

​