至少有五种方法。最好的选项，也应该是最快的(由于本机RegEx引擎)被放在顶部。

方法1

("this is foo bar".match(/o/g)||[]).length;
// returns 2

方法2

"this is foo bar".split("o").length - 1;
// returns 2

不建议拆分，因为它是资源饥渴的。它为每个匹配分配新的“Array”实例。不要通过FileReader尝试>100MB文件。你可以观察确切的资源使用使用Chrome的分析器选项。

方法3

    var stringsearch = "o"
       ,str = "this is foo bar";
    for(var count=-1,index=-2; index != -1; count++,index=str.indexOf(stringsearch,index+1) );
// returns 2

方法4

搜索单个字符

    var stringsearch = "o"
       ,str = "this is foo bar";
    for(var i=count=0; i<str.length; count+=+(stringsearch===str[i++]));
     // returns 2

方法5

元素映射和过滤。不建议这样做，因为它的整体资源预分配，而不是使用python的“生成器”:

    var str = "this is foo bar"
    str.split('').map( function(e,i){ if(e === 'o') return i;} )
                 .filter(Boolean)
    //>[9, 10]
    [9, 10].length
    // returns 2

分享: 我做了这个要点，目前有8种方法的字符计数，所以我们可以直接汇集和分享我们的想法-只是为了好玩，也许一些有趣的基准:)

Split与RegExp的性能

var i = 0; var split_start = new Date().getTime(); while (i < 30000) { "1234,453,123,324".split(",").length -1; i++; } var split_end = new Date().getTime(); var split_time = split_end - split_start; i= 0; var reg_start = new Date().getTime(); while (i < 30000) { ("1234,453,123,324".match(/,/g) || []).length; i++; } var reg_end = new Date().getTime(); var reg_time = reg_end - reg_start; alert ('Split Execution time: ' + split_time + "\n" + 'RegExp Execution time: ' + reg_time + "\n");

s = 'dir/dir/dir/dir/'
for(i=l=0;i<s.length;i++)
if(s[i] == '/')
l++

let str = "aabgrhaab"
let charMap = {}

for(let char of text) {
   if(charMap.hasOwnProperty(char)){
      charMap[char]++
   } else {
     charMap[char] = 1
   }
}

console.log (charMap);//{a: 4, b: 2, g: 1, r: 1, h: 1}

我更新了这个答案。我更喜欢使用火柴的想法，但它更慢:

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

如果事先知道要搜索什么，可以使用正则表达式文字;如果不知道，可以使用RegExp构造函数，并传入g标志作为参数。

匹配结果为空，因此|| []

以下是我在2009年给出的原始答案。它创建了一个不必要的数组，但是使用分割更快(截至2014年9月)。我很矛盾，如果我真的需要速度，毫无疑问我会使用分拆，但我更喜欢使用匹配。

旧答案(2009年):

如果你在找逗号:

(mainStr.split(",").length - 1) //3

如果你在找str

(mainStr.split("str").length - 1) //4

在@Lo的回答和我自己的愚蠢的性能测试中，分裂在速度上领先，至少在Chrome中，但再次创建额外的数组似乎不理智。

更新06/10/2022

所以我运行了各种性能测试，如果你的用例允许的话，使用split似乎会表现得最好。

function countChar(char: string, string: string): number  {

  return string.split(char).length - 1

}

countChar('x', 'foo x bar x baz x')

我知道我来晚了，但我很困惑，没有人用最基本的方法来回答这个问题。社区对这个问题提供的大部分答案都是基于迭代的，但都是在每个字符的基础上移动字符串，这并不是真正有效的。

When dealing with a large string that contains thousands of characters walking over each character to get the occurance count can become rather extraneous not to mention a code-smell. The below solutions take advantage of slice, indexOf and the trusted traditional while loop. These approaches prevent us having to walk over each character and will greatly speed up the time it takes to count occurances. These follow similar logic to that you'd find in parsers and lexical analyzers that require string walks.

与Slice一起使用

在这种方法中，我们利用切片和每个indexOf匹配，我们将通过字符串移动我们的方式，并消除之前搜索的药水。每次调用indexOf，它搜索的字符串的大小都会变小。

function countChar (char: string, search: string): number {
  
  let num: number = 0;
  let str: string = search;
  let pos: number = str.indexOf(char);
  
  while(pos > -1) {
    str = str.slice(pos + 1);
    pos = str.indexOf(char);
    num++;
  }

  return num;

}

// Call the function
countChar('x', 'foo x bar x baz x') // 3

使用IndexOf from position

类似于使用slice的第一种方法，但它不是扩大我们正在搜索的字符串，而是利用indexOf方法中的from参数。

function countChar (char: string, str: string): number {
  
  let num: number = 0;
  let pos: number = str.indexOf(char);
  
  while(pos > -1) {
    pos = str.indexOf(char, pos + 1);
    num++;
  }

  return num;

}

// Call the function
countChar('x', 'foo x bar x baz x') // 3

就我个人而言，我倾向于第二种方法而不是第一种，但在处理大字符串和较小尺寸的字符串时，两者都很好且性能良好。