Как посчитать вхождение строки в строку?

Question

Как подсчитать, сколько раз конкретная строка встречается в другой строке. Например, это то, что я пытаюсь сделать в Javascript:

var temp = "This is a string.";
alert(temp.count("is")); //should output '2'

Answer 1

var temp = "This is a string.";
console.log((temp.match(new RegExp("is", "g")) || []).length);

Answer 2

Я думаю, что цель регулярного выражения сильно отличается от indexOf.indexOf просто находит вхождение определенной строки, в то время как в регулярном выражении вы можете использовать подстановочные знаки, такие как [A-Z], что означает, что он найдет любой заглавный символ в слове без указания фактического символа.

Пример:

 var index = "This is a string".indexOf("is");
 console.log(index);
 var length = "This is a string".match(/[a-z]/g).length;
 // where [a-z] is a regex wildcard expression thats why its slower
 console.log(length);

Answer 3

       var myString = "This is a string.";
        var foundAtPosition = 0;
        var Count = 0;
        while (foundAtPosition != -1)
        {
            foundAtPosition = myString.indexOf("is",foundAtPosition);
            if (foundAtPosition != -1)
            {
                Count++;
                foundAtPosition++;
            }
        }
        document.write("There are " + Count + " occurrences of the word IS");

См. - количество подстрок в строке для пошагового объяснения.

Answer 4

Супер пупер старый, но мне нужно было сделать что-то подобное сегодня и только подумал, чтобы проверить это потом.Работает довольно быстро для меня.

String.prototype.count = function(substr,start,overlap) {
    overlap = overlap || false;
    start = start || 0;

    var count = 0, 
        offset = overlap ? 1 : substr.length;

    while((start = this.indexOf(substr, start) + offset) !== (offset - 1))
        ++count;
    return count;
};

Answer 5

Для любого, кто найдет этот поток в будущем, обратите внимание, что принятый ответ не всегда вернет правильное значение, если вы его обобщите, так как он задушит операторы регулярных выражений, такие как $ и .. Вот лучшая версия, которая может обрабатывать любую иглу:

function occurrences (haystack, needle) {
  var _needle = needle
    .replace(/\[/g, '\\[')
    .replace(/\]/g, '\\]')
  return (
    haystack.match(new RegExp('[' + _needle + ']', 'g')) || []
  ).length
}

Answer 6

function get_occurrence(varS,string){//Find All Occurrences
        c=(string.split(varS).length - 1);
        return c;
    }
    temp="This is a string.";
    console.log("Total Occurrence is "+get_occurrence("is",temp));

Используйте get_occurrence (varS, string), чтобы найти вхождение как символов, так и строки в строку.

Answer 7

Опираясь на @ Vittim.us ответ выше.Мне нравится контроль, который дает мне его метод, позволяющий легко расширять его, но мне нужно было добавить нечувствительность к регистру и ограничить совпадения целыми словами с поддержкой пунктуации.(например, «ванна» означает «принять ванну», но не «купание»)

Регулярное выражение пунктуации появилось из: https://stackoverflow.com/a/25575009/497745 ( Как можно удалить все знаки препинания из строкив JavaScript с использованием regex? )

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;
}

Пожалуйста, не стесняйтесь изменять и реорганизовывать этот ответ, если вы обнаружите ошибки или улучшения.

Answer 8

Это очень старая тема, с которой я сталкивался, но многие ответили на этот вопрос ответом, вот мой в надежде помочь кому-нибудь с этим простым кодом.

var search_value = "This is a dummy sentence!";
var letter = 'a'; /*Can take any letter, have put in a var if anyone wants to use this variable dynamically*/
letter = letter[letter.length - 1];
var count;
for (var i = count = 0; i < search_value.length; count += (search_value[i++] == letter));
console.log(count);

Я не уверен, что это самое быстрое решение, но я предпочел его для простоты и не использовать регулярные выражения (я просто не люблю их использовать!)

Answer 9

Попробуйте

<?php 
$str = "33,33,56,89,56,56";
echo substr_count($str, '56');
?>

<script type="text/javascript">
var temp = "33,33,56,89,56,56";
var count = temp.match(/56/g);  
alert(count.length);
</script>

Answer 10

Никто никогда не увидит этого, но хорошо бы время от времени возвращать функции рекурсии и стрелок (каламбур).

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