计算Javascript中字符串中字符的出现次数

我需要计算字符串中某个字符出现的次数

例如，假设我的字符串包含：

var mainStr = "str1,str2,str3,str4";

我想找到逗号

，

字符的计数，它是3。以及沿逗号拆分后的单个字符串的计数，即4

---

我还需要验证每个字符串，即str1或str2或str3或str4不应超过15个字符。

我已更新了此答案。我更喜欢使用火柴，但速度较慢：

console.log（（（“str1、str2、str3、str4.match（/，/g）| |[]）长度）//日志3
log（（（“str1，str2，str3，str4.match（新的RegExp（“str”，“g”）））| |[]）长度）//日志4

一次快速搜索（从中）得到了此信息

像这样使用它：

test = 'one,two,three,four'
commas = test.count(',') // returns 3

---

下面使用正则表达式测试长度。testex确保您没有16个或更多的连续非逗号字符。如果它通过了测试，则继续分割字符串。计算逗号与计算令牌减去1一样简单

var mainStr = "str1,str2,str3,str4";
var testregex = /([^,]{16,})/g;
if (testregex.test(mainStr)) {
  alert("values must be separated by commas and each may not exceed 15 characters");
} else {
  var strs = mainStr.split(',');
  alert("mainStr contains " + strs.length + " substrings separated by commas.");
  alert("mainStr contains " + (strs.length-1) + " commas.");
}

---

至少有五种方法。最好的选项也应该是最快的（由于本机正则表达式引擎），放在顶部

方法1

（“这是foo-bar.match（/o/g）| |[]）长度；
//返回2

方法2

“这是foo-bar”。拆分（“o”）。长度-1；
//返回2

不建议拆分，因为它需要大量资源。它为每个匹配分配“Array”的新实例。不要通过FileReader对大于100MB的文件进行尝试。您可以使用Chrome的profiler选项观察确切的资源使用情况

方法3

var stringsearch=“o”
，str=“这是foo-bar”；
对于（var count=-1，index=-2；index！=-1；count++，index=str.indexOf（stringsearch，index+1））；
//返回2

方法4 搜索单个字符

var stringsearch=“o”
，str=“这是foo-bar”；
对于（var i=count=0；i[9,10]
[9,10]。长度
//返回2

共享： 我用目前8种字符计数方法制作了这个，因此我们可以直接汇集和分享我们的想法——只是为了好玩，也许还有一些有趣的基准：）

s='dir/dir/dir/'
对于（i=l=0；i我的解决方案：

function countOcurrences(str, value){
   var regExp = new RegExp(value, "gi");
   return str.match(regExp) ? str.match(regExp).length : 0;  
}

我在一个需要子字符串计数器的小项目中工作。搜索错误的短语没有结果，但是在编写自己的实现后，我偶然发现了这个问题。无论如何，我的方法是这样的，它可能比这里的大多数方法慢，但可能对某些人有帮助：

function count_letters() {
var counter = 0;

for (var i = 0; i < input.length; i++) {
    var index_of_sub = input.indexOf(input_letter, i);

    if (index_of_sub > -1) {
        counter++;
        i = index_of_sub;
    }
}

函数计数字母（）{
var计数器=0；
对于（变量i=0；i-1）{
计数器++；
i=子项的索引；
}
}


如果您发现此实现失败或未遵循某些标准，请告诉我！：）

更新
您可能需要替换：

    for (var i = 0; i < input.length; i++) {

for（变量i=0；i

与：

for（变量i=0，输入长度=input.length；i

有趣的阅读讨论上述内容：
我发现在一个非常大的字符串中搜索字符（例如，长度为1000000个字符）的最佳方法是使用
replace（）
方法

window.count_replace = function (str, schar) {
    return str.length - str.replace(RegExp(schar), '').length;
};

您可以看到测试此方法的套件以及在字符串中查找字符的其他方法。
将此函数添加到sting prototype：

String.prototype.count=function(c) { 
  var result = 0, i = 0;
  for(i;i<this.length;i++)if(this[i]==c)result++;
  return result;
};

我对接受的答案做了一点改进，它允许使用区分大小写/不区分大小写的匹配进行检查，并且是附加到字符串对象的方法：

String.prototype.count = function(lit, cis) {
    var m = this.toString().match(new RegExp(lit, ((cis) ? "gi" : "g")));
    return (m != null) ? m.length : 0;
}

lit
是要搜索的字符串（例如“ex”），而CI是不区分大小写的，默认为false，它将允许选择不区分大小写的匹配项。

要在字符串
'I love StackOverflow.com'
中搜索小写字母
'o'
，您可以使用：

var amount_of_os = 'I love StackOverflow.com'.count('o');

var amount_of_os = 'I love StackOverflow.com'.count('o', true);

数量等于
2
。

如果我们使用不区分大小写的匹配再次搜索同一字符串，您将使用：

var amount_of_os = 'I love StackOverflow.com'.count('o');

var amount_of_os = 'I love StackOverflow.com'.count('o', true);

这次，
amount\u of_os
将等于
3
，因为字符串中的大写字母
O
将包含在搜索中。
好的，另一个带有regexp的-可能不快，但短且可读性更好，在我的情况下，只需计算
'

key.replace(/[^_]/g,'').length

只要删除所有看起来不像你的字符的东西
但是使用字符串作为输入看起来不太好
那么string.split（desiredCharecter）.length-1呢

例如：

var str=“你好，生活如何”；
var len=str.split（“h”）.length-1；将给出上述字符串中字符“h”的计数2；
我使用的是Node.js v.6.0.0，最快的是带有索引的（Lo Sauer答案中的第三种方法）

二是:


函数计数（s，c）{
var n=0；
for（设x/s）{
如果（x==c）
n++；
}
返回n；
}
拆分与RegExp的性能


var i=0；
var split_start=new Date（）.getTime（）；
而（i<30000）{
“1234453123324”。拆分（“，”）。长度为-1；
i++；
}
var split_end=new Date（）.getTime（）；
var split_time=split_end-split_start；
i=0；
var reg_start=new Date（）.getTime（）；
而（i<30000）{
（“123445312324”。匹配（/，/g）| |[]）。长度；
i++；
}
var reg_end=new Date（）.getTime（）；
var reg_time=reg_end-reg_start；
警报（'Split Execution time:'+Split\u time+“\n”+'RegExp Execution time:'+reg\u time+“\n”）；
这里有一个类似的解决方案，但它使用了
Array.prototype.reduce

function countCharacters(char, string) {
  return string.split('').reduce((acc, ch) => ch === char ? acc + 1: acc, 0)
}

如前所述，
String.prototype.split
比
String.prototype.replace
我发现的最简单的方法要快得多

范例-

str = 'mississippi';

function find_occurences(str, char_to_count){
    return str.split(char_to_count).length - 1;
}

find_occurences(str, 'i') //outputs 4

如果您使用的是lodash，该方法将执行以下操作：

_.countBy("abcda")['a'] //2

此方法也适用于阵列：

_.countBy(['ab', 'cd', 'ab'])['ab'] //2

这里有一个与
split（）
和t一样快的
_.countBy("abcda")['a'] //2

_.countBy(['ab', 'cd', 'ab'])['ab'] //2

// winner!
function charCount1(s, c) {
    let count = 0;
    c = c.charAt(0); // we save some time here
    for(let i = 0; i < s.length; ++i) {
        if(c === s.charAt(i)) {
            ++count;
        }
    }
    return count;
}

function charCount2(s, c) {
    return (s.match(new RegExp(c[0], 'g')) || []).length;
}

function charCount3(s, c) {
    let count = 0;
    for(ch of s) {
        if(c === ch) {
            ++count;
        }
    }
    return count;
}

function perfIt() {
    const s = 'Hello, World!';
    const c = 'o';

    console.time('charCount1');
    for(let i = 0; i < 10000; i++) {
        charCount1(s, c);
    }
    console.timeEnd('charCount1');
    
    console.time('charCount2');
    for(let i = 0; i < 10000; i++) {
        charCount2(s, c);
    }
    console.timeEnd('charCount2');
    
    console.time('charCount3');
    for(let i = 0; i < 10000; i++) {
        charCount2(s, c);
    }
    console.timeEnd('charCount3');
}

perfIt()
charCount1: 3.301ms
charCount2: 11.652ms
charCount3: 174.043ms
undefined

perfIt()
charCount1: 2.110ms
charCount2: 11.931ms
charCount3: 177.743ms
undefined

perfIt()
charCount1: 2.074ms
charCount2: 11.738ms
charCount3: 152.611ms
undefined

perfIt()
charCount1: 2.076ms
charCount2: 11.685ms
charCount3: 154.757ms
undefined

function countAllCharacters(str) {
  var obj = {};
  if(str.length!==0){
    for(i=0;i<str.length;i++){
      var count = 0;
      for(j=0;j<str.length;j++){
        if(str[i] === str[j]){
          count++;
        }
      }
      if(!obj.hasOwnProperty(str[i])){
        obj[str[i]] = count;
      }
    }
  }
  return obj;
}

function substring_count(source_str, search_str, index) {
    source_str += "", search_str += "";
    var count = -1, index_inc = Math.max(search_str.length, 1);
    index = (+index || 0) - index_inc;
    do {
        ++count;
        index = source_str.indexOf(search_str, index + index_inc);
    } while (~index);
    return count;
}

var a = "acvbasbb";
var b= {};
for (let i=0;i<a.length;i++){
    if((a.match(new RegExp(a[i], "g"))).length > 1){
        b[a[i]]=(a.match(new RegExp(a[i], "g"))).length;
    }
}
console.log(b);

function character_count(string, char, ptr = 0, count = 0) {
    while (ptr = string.indexOf(char, ptr) + 1) {count ++}
    return count
}

const testString = 'somestringtotest'

const countLetters = R.compose(
  R.map(R.length),
  R.groupBy(R.identity),
  R.split('')
)

countLetters(testString)

var charFoundMap = {};//object defined
    for (var i = 0; i < str.length; i++) {

       if(!charFoundMap[ str[i] ])  {
        charFoundMap[ str[i] ]=1;
       } 
       else
       charFoundMap[ str[i] ] +=1;
       //if object does not contain this 
    }
    return charFoundMap;

} 

const mainStr = 'str1,str2,str3,str4';

const commaAndStringCounter = (str) => {
  const commas = [...str].filter(letter => letter === ',').length;
  const numOfStr = str.split(',').length;

  return `Commas: ${commas}, String: ${numOfStr}`;
}

// Run the code
console.log(commaAndStringCounter(mainStr)); // Output: Commas: 3, String: 4