//Try this code

const countSubStr = (str, search) => {
    let arrStr = str.split('');
    let i = 0, count = 0;

    while(i < arrStr.length){
        let subStr = i + search.length + 1 <= arrStr.length ?
                  arrStr.slice(i, i+search.length).join('') :
                  arrStr.slice(i).join('');
        if(subStr === search){
            count++;
            arrStr.splice(i, search.length);
        }else{
            i++;
        }
    }
    return count;
  }

var str=“堆栈流”；var arr=Array.from（str）；控制台日志（arr）；for（设a=0；a<=arr.length；a++）{变量温度=arr[a]；变量c=0；for（设b=0；b<=arr.length；b++）{如果（温度==arr[b]）{c++；}}console.log（“${arr[a]}计入${c}”）}

正则表达式（global的缩写）中的g表示搜索整个字符串，而不仅仅是查找第一个出现的字符串。此匹配是两次：

var temp=“这是一个字符串。”；var count=（temp.match（/is/g）| |[]）.length；console.log（计数）；

如果没有匹配项，则返回0：

var temp=“Hello World！”；var count=（temp.match（/is/g）| |[]）.length；console.log（计数）；

第二次迭代次数较少（仅当子字符串的第一个字母匹配时），但循环仍使用2：

   function findSubstringOccurrences(str, word) {
        let occurrences = 0;
        for(let i=0; i<str.length; i++){
            if(word[0] === str[i]){ // to make it faster and iterate less
                for(let j=0; j<word.length; j++){
                    if(str[i+j] !== word[j]) break;
                    if(j === word.length - 1) occurrences++;
                }
            }
        }
        return occurrences;
    }
    
    console.log(findSubstringOccurrences("jdlfkfomgkdjfomglo", "omg"));

我的解决方案：

var temp=“这是一个字符串。”；函数countOccurrences（str，value）{var regExp=新regExp（值，“gi”）；return（str.match（regExp）| |[]）.length；}console.log（countOccurrences（temp，'is'））；

这是最快的功能！

为什么速度更快？

不逐个字符检查（有1个例外）使用while并增加1个var（字符计数var），而不是for循环检查长度并增加2个var（通常是var i和一个带有字符计数的var）使用WAY less vars不使用正则表达式！使用（希望）高度优化的函数所有操作都尽可能地组合在一起，避免了由于多次操作而导致的速度减慢String.product.timesCharExist=函数（c）｛var t=0，l=0，c=（c+“”）[0]；while（l=this.indexOf（c，l）+1）++t；return t｝；

以下是一个更慢、更可读的版本：

    String.prototype.timesCharExist = function ( chr ) {
        var total = 0, last_location = 0, single_char = ( chr + '' )[0];
        while( last_location = this.indexOf( single_char, last_location ) + 1 )
        {
            total = total + 1;
        }
        return total;
    };

由于计数器、长的var名称和对1var的误用，这个速度较慢。

要使用它，只需执行以下操作：

    'The char "a" only shows up twice'.timesCharExist('a');

编辑：（2013/12/16）

不要与Opera 12.16或更高版本一起使用！它将比正则表达式解决方案花费几乎2.5倍的时间！

在chrome上，对于1000000个字符，此解决方案需要14ms到20ms。

相同量的regex溶液需要11-14ms。

使用函数（String.prototype外部）大约需要10-13ms。

以下是使用的代码：

    String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

    var x=Array(100001).join('1234567890');

    console.time('proto');x.timesCharExist('1');console.timeEnd('proto');

    console.time('regex');x.match(/1/g).length;console.timeEnd('regex');

    var timesCharExist=function(x,c){var t=0,l=0,c=(c+'')[0];while(l=x.indexOf(c,l)+1)++t;return t;};

    console.time('func');timesCharExist(x,'1');console.timeEnd('func');

所有解决方案的结果应该是100000！

注意：如果您希望此函数计数超过1个字符，请将其中的c=（c+“”）[0]更改为c=c+“”