基于@Vittim.us的上述回答。我喜欢他的方法给我的控制，使其易于扩展，但我需要添加不区分大小写的功能，并将匹配限制在支持标点符号的整个单词中。（例如，“洗澡”是指“洗澡”，而不是“洗澡”）

标点正则表达式来自：https://stackoverflow.com/a/25575009/497745（如何使用正则表达式从JavaScript字符串中删除所有标点符号？）

function keywordOccurrences(string, subString, allowOverlapping, caseInsensitive, wholeWord)
{

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1); //deal with empty strings

    if(caseInsensitive)
    {            
        string = string.toLowerCase();
        subString = subString.toLowerCase();
    }

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length,
        stringLength = string.length,
        subStringLength = subString.length;

    while (true)
    {
        pos = string.indexOf(subString, pos);
        if (pos >= 0)
        {
            var matchPos = pos;
            pos += step; //slide forward the position pointer no matter what

            if(wholeWord) //only whole word matches are desired
            {
                if(matchPos > 0) //if the string is not at the very beginning we need to check if the previous character is whitespace
                {                        
                    if(!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchPos - 1])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }

                var matchEnd = matchPos + subStringLength;
                if(matchEnd < stringLength - 1)
                {                        
                    if (!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchEnd])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }
            }

            ++n;                
        } else break;
    }
    return n;
}

如果发现错误或改进，请随时修改和重构此答案。

只需编码打高尔夫球丽贝卡·切尔诺夫的解决方案：-）

alert(("This is a string.".match(/is/g) || []).length);

没有人会看到这一点，但偶尔带回递归和箭头函数是很好的（双关语的意思很好）

String.prototype.occurrencesOf = function(s, i) {
 return (n => (n === -1) ? 0 : 1 + this.occurrencesOf(s, n + 1))(this.indexOf(s, (i || 0)));
};

第二次迭代次数较少（仅当子字符串的第一个字母匹配时），但循环仍使用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 search_value=“这是一个假句子！”；var letter='a'/*可以接受任何字母，如果任何人想动态使用此变量，请输入一个var*/letter=letter&&“string”===字母类型？字母：“”；变量计数；对于（var i=count=0；i<search_value.length；count+=（search_value[i++]==字母））；console.log（计数）；

我不确定它是否是最快的解决方案，但我更喜欢它，因为它简单且不使用正则表达式（我只是不喜欢使用它们！）

这是我的解决方案。我希望这会对某人有所帮助

const countOccurence = (string, char) => {
const chars = string.match(new RegExp(char, 'g')).length
return chars;
}