如何使用for语句制作更简洁的代码

Question

我是stackoverflow和javaScript的新手，我正在尝试从考虑大写和小写字母的字符串中重复的第一个字母，并使用for语句来计数和获得结果。问题在于我使用的表格太长分析情况达到了这样的观点，也许您只能使用"用于此练习的"语句被阻止的是，这就是为什么我请求帮助理解并继续理解和使用该句子的原因。在这种情况下，结果在函数内的JavaScript脚本中进行了测试，3"句子获得了相当积极的结果，但是我不能仅以1为1(对不起我的不良英语Google翻译(

i用javasscript在html中制作

var letter = "SYAHSVCXCyXSssssssyBxAVMZsXhZV";
var contendor = [];
var calc = [];
var mycalc = 0;
letter = letter.toUpperCase()
console.log(letter)
function repeats(){
  for (var i = 0; i < letter.length; i++) {
    if (contendor.includes(letter[i]))   {
    }else{
        contendor.push(letter[i])
        calc.push(0)
    }
  }
  for (var p = 0; p < letter.length; p++) {
    for (var l = 0; l < contendor.length; l++) {
          if (letter[p] == contendor[l])  {
              calc [l]= calc [l]+1
          }
    }
  }
  for (var f = 0; f < calc.length; f++) {
    if ( calc[f] > calc[mycalc]) {
            mycalc = f
    }
  }
 }
repeats()
console.log("The most repeated letter its: " + contendor[mycalc]);

我期望：带有简洁代码的结果

Answer 1

使用正则表达式可能会更简洁：匹配一个字符，然后lookahead for更多字符，直到您可以再次匹配第一个字符：

var letter = "SYAHSVCXCyXSssssssyBxAVMZsXhZV";
const firstRepeatedRegex = /(.)(?=.*1)/;
console.log(letter.match(firstRepeatedRegex)[1]);

当然，如果您不确定给定字符串是否包含重复的字符，请在尝试提取字符之前检查匹配不是null：

const input = 'abcde';
const firstRepeatedRegex = /(.)(?=.*1)/;
const match = input.match(firstRepeatedRegex);
if (match) {
  console.log(match[0]);
} else {
  console.log('No repeated characters');
}

您也可以将输入转换为数组，并使用.find找到lastIndexOf与迭代字符索引的第一个字符：

const getFirstRepeatedCharacter = (str) => {
  const chars = [...str];
  const char = chars.find((char, i) => chars.lastIndexOf(char) !== i);
  return char || 'No repeated characters';
};
console.log(getFirstRepeatedCharacter('abcde'));
console.log(getFirstRepeatedCharacter('SYAHSVCXCyXSssssssyBxAVMZsXhZV'));

如果您实际寻找的是最常发生的字符，请使用reduce将字符串转换为由字符索引的对象，其值是该字符的出现数量，然后确定最大价值：

const getMostRepeatedCharacter = (str) => {
  const charsByCount = [...str.toUpperCase()].reduce((a, char) => {
    a[char] = (a[char] || 0) + 1;
    return a;
  }, {});
  const mostRepeatedEntry = Object.entries(charsByCount).reduce((a, b) => a[1] >= b[1] ? a : b);
  return mostRepeatedEntry[0];
};
console.log(getMostRepeatedCharacter('abcde'));
console.log(getMostRepeatedCharacter('SYAHSVCXCyXSssssssyBxAVMZsXhZV'));

Answer 2

如果第一个重复的字符是您想要的，则可以将其推入数组，并检查字符是否已经存在

function getFirstRepeating( str ){
    chars = []
    for ( var i = 0; i < str.length; i++){
        var char = str.charAt(i);
        if ( chars.includes( char ) ){
            return char;
        } else {
            chars.push( char );
        }
    }
    return -1;
}

这将返回第一个重复字符(如果存在(，或者将返回-1。

工作

function getFirstRepeating( str ){
  chars = []
  for ( var i = 0; i < str.length; i++){
    var char = str.charAt(i);
    if ( chars.includes( char ) ){
      return char;
        } else {
      chars.push( char );
        }
    }
  return -1;
}
console.log(getFirstRepeating("SYAHSVCXCyXSssssssyBxAVMZsXhZV"))

Answer 3

您是否使用JavaScript对象？

您应该研究它。

当您循环穿过字符串

let characters = "hemdhdksksbbd";
let charCount = {};
let max = { count: 0, ch: ""}; // will contain max 
                                                 // rep letter
 //Turn string into an array of letters and for 
  // each letter create a key in the charcount 
 // object , set it to 1 (meaning that's the first of 
 // that letter you've found) and any other time 
 // you see the letter, increment by 1.
characters.split("").forEach(function(character)
{
    if(!charCount[character])
        charCount[character] = 1;
    else
        charCount[character]++;
}
 //charCount should now contain letters and 
  // their counts.
  //Get the letters from charCount and find the 
  // max count
Object.keys(charCount). forEach (function(ch){
        if(max.count < charCount[ch])
              max = { count: charCount[ch], ch: ch};
 }
console.log("most reps is: " , max.ch);

Answer 4

这是一个非常可怕的解决方案。它需要2个循环(reduce(，并且不处理领带，但短而复杂。

基本上继续将结果变成数组，并使用数组方法split和reduce查找答案。第一个reduce包裹在Object.entries()中以将对象转回数组。

let letter = Object.entries(
               "SYAHSVCXCyXSssssssyBxAVMZsXhZV".
               toUpperCase().
               split('').
               reduce((p, c) => {
                 p[c] = isNaN(++p[c]) ? 1 : p[c];
                 return p;
               }, {})
             ).
             reduce((p, c) => p = c[1] > p[1] ? c : p);
console.log(`The most repeated letter is ${letter[0]}, ${letter[1]} times.`);