使用 JavaScript 计算字符串中字符的频率

Question

我需要编写某种循环来计算字符串中每个字母出现的频率。

例如："aabsssd"

输出：a:2, b:1, s:3, d:1

还想在对象中映射与属性名称相同的字符。有什么好主意吗？

我不知道该怎么做。

这是我目前的位置：

var arr = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];

function counter(x) {
  var count = 0,
    temp = [];
  x = x.split('');
  console.log(x);
  for (var i = 0, len = x.length; i < len; i++) {
    if (x[i] == "a") {
      count++;
    }
  }
  return count;
}
var a = "aabbddd";
console.log(counter(a));

Answer 1

给你：

function getFrequency(string) {
    var freq = {};
    for (var i=0; i<string.length;i++) {
        var character = string.charAt(i);
        if (freq[character]) {
           freq[character]++;
        } else {
           freq[character] = 1;
        }
    }

    return freq;
};

Answer 2

一些带有reduce的ES6语法：

let counter = str => {
  return str.split('').reduce((total, letter) => {
    total[letter] ? total[letter]++ : total[letter] = 1;
    return total;
  }, {});
};

counter("aabsssd"); // => { a: 2, b: 1, s: 3, d: 1 }

Answer 3

另一种解决方案：

function count (string) {  
  var count = {};
  string.split('').forEach(function(s) {
     count[s] ? count[s]++ : count[s] = 1;
  });
  return count;
}

Answer 4

具有一些 ES6 特性和短路功能：

const counter = s => [...s].reduce((a, c) => (a[c] = a[c] + 1 || 1) && a, {})

console.log(
  counter("hello") // {h: 1, e: 1, l: 2, o: 1}
)  

Answer 5

这是另一种方式：

const freqMap = s => [...s].reduce((freq,c) => {freq[c] = -~freq[c]; return freq} ,{})

或者，如果您更喜欢“for”循环：

function freqMap(s) { 
   freq={}; 
   for (let c of s) 
      freq[c]=-~freq[c]; 
   return freq;
}

例如freqMap("MaMaMia") 返回Object{M : 3, a : 3, i : 1}

此方法利用了这样一个事实，即在 javascript 中，按位不在“未定义”上给出 -1，（而“未定义 + 1”给出 NaN）。 所以，-~undefined 是 1，-~1 是 2，-~2 是 3 等等。

因此，我们可以遍历字符串的字符，并简单地递增freq[c] 而无需任何“if”。我们第一次遇到字符c，freq[c] 将是未定义的，所以我们将其设置为-~freq[c]，即1。如果我们随后再次遇到c，我们再次将freq[c] 设置为-~freq[c]，现在将是2，等等。

简单、优雅、简洁。

Answer 6

获取单词直方图的更具说明性的方法是利用 reduce 遍历字母并提出一个包含字母作为键和频率作为值的新对象。

function getFrequency(str) {
  return str.split('').reduce( (prev, curr) => {
    prev[curr] = prev[curr] ? prev[curr] + 1 : 1;
    return prev;
  }, {});
};

console.log(getFrequency('test')); // => {t: 2, e: 1, s: 1}

Answer 7

更精简、更实用的解决方案：

使用 ES6 箭头 && 逻辑运算符：

const buildFreqDict = string =>
  string.split('').reduce((freqDict, char) => {
    freqDict[char] = (freqDict[char] || 0) + 1;
    return freqDict;
  }, {})

console.log(buildFreqDict("banana"))

解释

• 拆分 字符串 成字符数组。
  • 然后将其输入 reduce 方法（使用 method.chaining()）。
• 如果 char 已经登录 countDict 则加 1。
  • 或如果在 countDict 中找不到字符，则将其设置为 1。
• 将新值返回到 reduce 的累加器对象
• 注意：不要忘记包含 .reduce() 的第三个参数：在这种情况下，它是一个 {}（对象字面量），用于初始化 freqDict 对象。

有关更多信息，请参阅计算对象中值的实例在页面的中间：MDN Reduce
有关使用逻辑运算符的更多信息，请参阅此处：MDN Logical Operators

Answer 8

一个简单的方法。此外，它还为您提供按字母顺序排序的列表。它遍历一个数组并评估字符是否已经在对象中：如果为 false，则将字符添加到对象中，如果为 true，则其频率增加一个单位。

const text= "Lorem ipsum dolor sit amet consectetur adipiscing"
const textAsArray = text.split('').sort()
let charactersList = {}

for (char of textAsArray) {

   if (!charactersList[char]) {
    charactersList[char]=1;
   }
   else {
    charactersList[char]++
  }
}

console.log(charactersList)   

Answer 9

我已经审查过，我认为这非常适合他们提出的需求。我希望它在一行中，但我不知道如何动态生成对象。

const uniqueCount=(arr)=>{
let rs ={};
arr.sort().join("").match(/(.)(\1*)/g).map(i=>rs[i[0]]=i.length);
return rs;
};
console.log(uniqueCount(["a","b","c","d","d","e","a","b","c","f","g","h","h","h","e","a"]));
//{ a: 3, b: 2, c: 2, d: 2, e: 2, f: 1, g: 1, h: 3 }

我发现如上所述使用.match() 和正则表达式/(.)(\1*)/g 非常成功。

如果只是一个字符串，你只需要在前面加上一个.split("")就可以了。

Answer 10

还有一个按字母顺序排序的版本。此功能适用于两者。

1. 按字母顺序排列的字符频率
2. 按出现顺序排列的字符频率

警告：仅当整个字符串为小写时才有效

function freqWithAlphabetTable(str, doNeedToSort) {
    let cnt = new Array(26).fill(0), firstLowerCase = 97, output = {}
    for (let i = 0; i < str.length; i++)
        cnt[str[i].charCodeAt(0) - firstLowerCase]++ // filling the array with count at it's index
    if (doNeedToSort) {
        for (let i = 0; i < cnt.length; i++) {
            if (cnt[i] !== 0)
                output[String.fromCharCode(firstLowerCase)] = cnt[i]
            firstLowerCase++;
        }
    } else {
        for (let i = 0; i < str.length; i++) {
            let letterIndexVal = cnt[str[i].charCodeAt(0) - firstLowerCase];
            if (letterIndexVal != 0 ) {
                output[str[i]] = letterIndexVal
                letterIndexVal = 0 // replacing it with zero to avoid repetition
            }
        }
    }
    console.log(output);
    return output;
}

Answer 11

for(i = strlen(string)var string = 'aabsssd';
var chars = new Array();
for(var i = 0; i < string.length; i++){
    var char = string.charAt(i);
    if(chars[char] == undefined){
        chars[char] = 0;
    }
    chars[char]++;
}
console.log(chars);

Answer 12

这是另一个使用 underscore.js 的选项：

function charCount(str) {
    return _(str.split('')).countBy(function(char) {
        return char.toLowerCase();
    });
}

charCount('aaabbbbdd') 输出Object {a: 3, b: 4, d: 2}

Answer 13

 const recorrences = ['a', 'b', 'c', 'a', 'b','a']
                .map(i => !!~i.indexOf('a'))
                .filter(i => i)
                .length;
console.log(`recorrences ${recorrences}`) 
//recorrences 3

Answer 14

// Count frequency of characters in a string
// input: 'Hello, I'm Paul!'
// result: {
//      H: 1,
//      E: 1,
//      L: 3,
//      ... and so on ...
// }

const countChars = (string) => {
    let charStats = {};
    string = string.replace(' ', '').toUpperCase().split('');

    string.forEach((char) => {
        if (charStats[char]) {
            charStats[char]++;
        } else {
            charStats[char] = 1;
        }
    });

    return charStats;
};

Answer 15

另一种解决方案

    function maxChar(str) {

        const charMap = {};
        let max = 0;
        let maxChar = '';

        for(let char of str){
            if(charMap[char]){
                charMap[char]++;
            }else{
                charMap[char] = 1;
            }
        }

        for(let char in charMap){
            if(charMap[char] > max){
                max = charMap[char];
                maxChar = char;
            }
        }

        return maxChar; 
}

===>

 maxChar('355385') 
  "5"

Answer 16

var str = 'abcccdddd';

function maxCharCount(target) {
    const chars = {};

    let maxChar = '';
    let maxValue = 1;

    for (let char of target) {
        chars[char] = chars[char] + 1 || 1;
    }

    return chars;
}

console.log(maxCharCount(str));

Answer 17

相同的解决方案，但重构。太酷了，我们如何用这么多不同的答案来解决这个问题:)

function getFrequency(string) {

    var freq = {};

    for (let character in string) {

         let char = string[character];        
         (freq[char]) ? freq[char]++ : freq[char] = 1

    }

    return freq;

};

Answer 18

你可以使用它。只需传递字符串，它将返回具有所有字符频率的对象。

function buildCharMap(string) {
  const charMap = {};
  string.replace(/[^\w]/g, '').toLowerCase();
  for (let char of string) {
    charMap[char] = charMap[char] + 1 || 1;
  }
  return charMap;
}

Answer 19

 [...str].map( char => map.get(char) ? map.set( char, map.get(char) + 1) : map.set(char,1) ) 

Answer 20

计算字符串中字符频率的作弊码是

let target = "e";
let string = " i want to see that person that came in here last";
let frequency = string.split(target).length - 1;

或全部在一行

console.log(string.split("e").length - 1)