Question

我是StackOverflow和JavaScript的新手，我正在尝试从字符串中获取第一个重复的字母，同时考虑到大写和小写字母，并使用for语句计数并获取结果。问题是我使用的表格太长了，分析情况到了这样的程度，也许您只能对此练习使用“ For”语句，但我要对其进行迭代，但不能使用更简洁和精简的代码来完全完成我的工作被屏蔽，这就是为什么我请求帮助来理解并继续理解和使用这句话的原因。在这种情况下，结果在函数中的JavaScript脚本中进行了测试，并且3个“ For”语句获得了非常肯定的结果，但我不能仅在1个For中创建它（对不起，我的英语谷歌翻译不好）

我使用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

使用正则表达式可能会更简洁：匹配一个字符，然后先查找更多字符，直到可以再次匹配第一个字符为止：

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.`);

如何使用For语句编写更简洁的代码？

4 个答案: