js如何找出一个字符串中出现次数最多的字符

Question

js如何找出一个字符串中出现次数最多的字符，并且统计这个次数？
比如。
let str = "hajjfhlhhff"

结果要打印：h出现次数最多 ， 出现3次

Answer 1

上面的方法其实都没有问题，这里稍微从算法的角度提一点优化的可能。
这个算法影响效率的主要是遍历，我看上面都是用的2次遍历（1次遍历原始数据，1次遍历生成的对象数据，这里只用了英文字符，如果是允许UTF-8字符全集，这样的遍历可能也是一个麻烦事情吧），其实可以优化来只遍历1次就可以输出（前提是输出最大的——最先出现最大的）。当然，理论上其实可能2次遍历可能开销还要小一些，因为比较的次数是和独立字符数量相关的，普遍意义上，一个字符串中独立字符数量是小于等于字符串中字符数的。

var obj = {}; // 先定义一个空对象,稍后使用.
var maxChar=''; // 要输出的字符
var maxN=0;// 字符数量

for (var i = 0; i < str.length; i++) { //   循环字符串中每一项
    var k = str[i]; // 把每一项保存给变量 k (对这一步不理解可先熟悉 for循环机制);

    if (obj[k]) {

        obj[k]++;
    } else {
        obj[k] = 1;
    }
    if(obj[k]>maxN){
        maxChar=k;
        maxN=obj[maxChar];
    }
}
console.log(maxChar, maxN);

Answer 2

构造一个object,键为字符，值为出现次数
遍历字符串，判断字符是否在object中‘如果不在则写入’值为1，如果在则值＋1
按照值排序‘去除第一个值的键即可

Answer 3

const str = 'hajjfhlhhff'
const arr = str.split('')

function Tools() {}
Tools.prototype.getMaxItems = function(obj) {
  const returnItems = []
  const maxValue = Math.max(...Object.keys(obj).map(key => obj[key]))
  Object.keys(obj).map(key => {
    if (obj[key] === maxValue) {
      returnItems.push({ [key]: obj[key] })
    }
  })
  return returnItems
}
Tools.prototype.getOBJList = function(arr) {
  return arr.reduce(function(prev, next) {
    prev[next] = (prev[next] + 1) || 1
    return prev
  }, {})
}
const tools = new Tools()
console.log(tools.getMaxItems(tools.getOBJList(arr)))

代码还有很多可改进的区间，不过这个样子逻辑应该很清楚了
PS：如果字符串中最大个数是一样的，都会返回

Answer 4

有点low

let str = "hajjfhlhhff";
let res = str.split('').reduce((pre,cur) => {
  if (cur in pre) {
      pre[cur] += 1;
  } else {
      pre[cur] = 1;
  }
  return pre;
},{})
let maxValue = Math.max(...Object.values(res));
Object.keys(res).forEach(key => {
  if (res[key] == maxValue) {
      console.log(`${key}出现次数最多 ， 出现${maxValue}次`)
  }
})

Answer 5

非完整代码，仅是表示一种思路。

console.log(str.split('').sort().join('').match(/(\w)\1{1,}/g).sort((a,b)=>a.length<=b.length)[0]);

Answer 6

function find(str) {
    var char = "";
    var count = 0;
    if (typeof str === "string") {
        var obj = {};
        for (var i = 0; i < str.length; ++i) {
            obj[str[i]] = ++obj[str[i]] || 1;
        }
        for (var key in obj) {
            if (obj[key] > count) {
                char = key;
                count = obj[key];
            }
        }
    }
    return char + "出现次数最多，出现" + count + "次";
}
console.log(find("hajjfhlhhff"));

Answer 7

function findMost(str) {
  var counts = {};
  var words = str.split('');
  
  for (var i = 0; i < words.length; i++) {
    counts[words[i]] = (counts[words[i]] || 0) + 1;
  }

  var result = { count: 0 };
  for (var word in counts) {
    if (counts[word] > res.count) {
      result = { word, count: counts[word] }
    }
  }

  return result;
}

Answer 8

回答的很多了, 好像都没有注释, 我来写上注释, 虽然不那么高大上, 但应该是最容易理解的
另外, 你写的h出现最多 是4次 不是3次;

let str = 'hajjfhlhhff'; // 定义字符串

var obj = {}; // 先定义一个空对象,稍后使用.

for (var i = 0; i < str.length; i++) { //   循环字符串中每一项
    var k = str[i]; // 把每一项保存给变量 k (对这一步不理解可先熟悉 for循环机制);

    if (obj[k]) {

        obj[k]++;
    } else {
        obj[k] = 1;
    }
}

console.log(obj); // 输出{d: 1, j: 6, a: 1, o: 2, u: 2, …};

let num = 0;
let value = null;
for (var j in obj) {
    if (obj[j] > num) {
        num = obj[j];            // 这一步是找出出现最多的那个字母, 也就是最大的那个数
        value = j;
    }
}

console.log(value, num); // 输出 "h" 4

流程共分为两部, 第一步是先把每个字母出现的次数计算出来; 第二步是把出现最多的那个字母和次数找出来;
建议你把数组去重写熟练;  对待这个就小菜一碟了;

Answer 9

let str = "hajjfhlhhff";
let result = str.split('').reduce((obj, cur) => {
    obj[cur] = obj[cur] ? obj[cur] + 1 : 1;
    return obj;
}, {});
console.log(result);

Answer 10

  <script>
    var maxNumber = function(digits) {
      const arr = digits.split(''); // 将字符串转成数组
      let hash = {}; // 定义hash用来计算
      for (let i = 0; i < arr.length; i++) {
        // 如果当前hash中没有该元素 数量为1 如果有 数量+=1
        hash[arr[i]] = !hash[arr[i]] ? 1 : (hash[arr[i]] += 1);
      }
      // 根据键值排序键名
      let keys = Object.keys(hash);
      keys.sort((a, b) => {
        return hash[b] - hash[a];
      });
      return `${keys[0]}出现次数最多，出现${hash[keys[0]]}次`;
    };
    console.log(maxNumber('hajjfhlhhffhhhh'));
  </script>

Answer 11

            let str="hajjfhlhhff";
            let _arr = []; // 存储统计数用
            let tmp = []; // 临时存储其中一个字母的数量

            for (let val of str) {
                tmp = str.match(eval("/"+val+"/g"));
                // tmp 的长度就是该字母重复出现的次数
                if (_arr[tmp.length] === undefined) {
                    _arr[tmp.length] = val;
                }else if ( !_arr[tmp.length].includes(val)){
                    // 把相同数量的字母拼在一起显示
                    _arr[tmp.length] = val + ',' + _arr[tmp.length];
                }
            }

            // _arr 的索引位置就是字母重复出现的次数
            console.log(_arr);

Answer 12

你们都好厉害

        const str = "aababcc;alsdjfl;asjfojpowroqwejrj;j;j;lj;ja;sdnf";
        const strArr = Array.from(str);

        // 计算次数
        const countFun = (arr, val) => {
            let i = 0;
            return arr.reduce((p, n) => {
                return n === val ? i++ : i
            }, 0)
        }

        let result = [];
        strArr.forEach(item => {
            result.push(countFun(strArr, item));
        });

        let maxNum = Math.max.apply(null, result);
        let maxIndex = result.findIndex(val => val === maxNum);
        let maxStr = strArr[maxIndex];

        console.log(`字符${maxStr}出现${maxNum}次`);

Answer 13

昨天被问到,今天整理一下.

var str='ni~ni~ni~niyaotiaowuma?';
var obj={};
var max=0;
var result;
[...str].map(x=>{
    obj.hasOwnProperty(x)?obj[x]++:obj[x]=1;
    if(obj[x]>max){
        max=obj[x];
        result=x;
    }
})
console.log(result);