如何统计字符串在字符串中的出现次数？

Question

How can I count the number of times a particular string occurs in another string. For example, this is what I am trying to do in Javascript:

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

Answer 1

The g in the regular expression (short for global ) says to search the whole string rather than just find the first occurrence. This matches is twice:

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

And, if there are no matches, it returns 0 :

 var temp = "Hello World!"; var count = (temp.match(/is/g) || []).length; console.log(count);

Answer 2

/** Function that count occurrences of a substring in a string;
 * @param {String} string               The string
 * @param {String} subString            The sub string to search for
 * @param {Boolean} [allowOverlapping]  Optional. (Default:false)
 *
 * @author Vitim.us https://gist.github.com/victornpb/7736865
 * @see Unit Test https://jsfiddle.net/Victornpb/5axuh96u/
 * @see http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string/7924240#7924240
 */
function occurrences(string, subString, allowOverlapping) {

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1);

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

    while (true) {
        pos = string.indexOf(subString, pos);
        if (pos >= 0) {
            ++n;
            pos += step;
        } else break;
    }
    return n;
}

Usage

occurrences("foofoofoo", "bar"); //0

occurrences("foofoofoo", "foo"); //3

occurrences("foofoofoo", "foofoo"); //1

allowOverlapping

occurrences("foofoofoo", "foofoo", true); //2

Matches:

  foofoofoo
1 `----´
2    `----´

Unit Test

• https://jsfiddle.net/Victornpb/5axuh96u/

Benchmark

I've made a benchmark test and my function is more then 10 times faster then the regexp match function posted by gumbo. In my test string is 25 chars length. with 2 occurences of the character 'o'. I executed 1 000 000 times in Safari.

Safari 5.1

Benchmark> Total time execution: 5617 ms (regexp)

Benchmark> Total time execution: 881 ms (my function 6.4x faster)

Firefox 4

Benchmark> Total time execution: 8547 ms (Rexexp)

Benchmark> Total time execution: 634 ms (my function 13.5x faster)

---

Edit: changes I've made

• cached substring length

• added type-casting to string.

• added optional 'allowOverlapping' parameter

• fixed correct output for "" empty substring case.

Gist

• https://gist.github.com/victornpb/7736865

Answer 3

function countInstances(string, word) {
   return string.split(word).length - 1;
}

Answer 4

You can try this:

 var theString = "This is a string."; console.log(theString.split("is").length - 1);

Answer 5

My solution:

 var temp = "This is a string."; function countOcurrences(str, value) { var regExp = new RegExp(value, "gi"); return (str.match(regExp) || []).length; } console.log(countOcurrences(temp, 'is'));

Answer 6

You can use match to define such function:

String.prototype.count = function(search) {
    var m = this.match(new RegExp(search.toString().replace(/(?=[.\\+*?[^\]$(){}\|])/g, "\\"), "g"));
    return m ? m.length:0;
}

Answer 7

The non-regex version:

 var string = 'This is a string', searchFor = 'is', count = 0, pos = string.indexOf(searchFor); while (pos > -1) { ++count; pos = string.indexOf(searchFor, ++pos); } console.log(count); // 2

Answer 8

只是打高尔夫球Rebecca Chernoff的解决方案:-)

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

Answer 9

 String.prototype.Count = function (find) { return this.split(find).length - 1; } console.log("This is a string.".Count("is"));

This will return 2.

Answer 10

Here is the fastest function!

Why is it faster?

• Doesn't check char by char (with 1 exception)
• Uses a while and increments 1 var (the char count var) vs. a for loop checking the length and incrementing 2 vars (usually var i and a var with the char count)
• Uses WAY less vars
• Doesn't use regex!
• Uses an (hopefully) highly optimized function

• All operations are as combined as they can be, avoiding slowdowns due to multiple operations

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

Here is a slower and more readable version:

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

This one is slower because of the counter, long var names and misuse of 1 var.

To use it, you simply do this:

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

Edit: (2013/12/16)

DON'T use with Opera 12.16 or older! it will take almost 2.5x more than the regex solution!

On chrome, this solution will take between 14ms and 20ms for 1,000,000 characters.

The regex solution takes 11-14ms for the same amount.

Using a function (outside String.prototype ) will take about 10-13ms.

Here is the code used:

    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');

The result of all the solutions should be 100,000!

Note: if you want this function to count more than 1 char, change where is c=(c+'')[0] into c=c+''

Answer 11

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

Answer 12

I think the purpose for regex is much different from indexOf . indexOf simply find the occurance of a certain string while in regex you can use wildcards like [AZ] which means it will find any capital character in the word without stating the actual character.

Example:

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

Answer 13

Super duper old, but I needed to do something like this today and only thought to check SO afterwards. Works pretty fast for me.

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 14

       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");

Refer :- count a substring appears in the string for step by step explanation.

Answer 15

For anyone that finds this thread in the future, note that the accepted answer will not always return the correct value if you generalize it, since it will choke on regex operators like $ and . . Here's a better version, that can handle any needle:

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

Answer 16

Building upon @Vittim.us answer above. I like the control his method gives me, making it easy to extend, but I needed to add case insensitivity and limit matches to whole words with support for punctuation. (eg "bath" is in "take a bath." but not "bathing")

The punctuation regex came from: https://stackoverflow.com/a/25575009/497745 ( How can I strip all punctuation from a string in JavaScript using 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;
}

Please feel free to modify and refactor this answer if you spot bugs or improvements.

Answer 17

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

Use get_occurrence(varS,string) to find occurrence of both characters and string in a String.

Answer 18

Try it

<?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 19

Simple version without regex:

 var temp = "This is a string."; var count = (temp.split('is').length - 1); alert(count);

Answer 20

No one will ever see this, but it's good to bring back recursion and arrow functions once in a while (pun gloriously intended)

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

Answer 21

Now this is a very old thread i've come across but as many have pushed their answer's, here is mine in a hope to help someone with this simple code.

 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 && "string" === typeof letter ? letter : ""; var count; for (var i = count = 0; i < search_value.length; count += (search_value[i++] == letter)); console.log(count);

I'm not sure if it is the fastest solution but i preferred it for simplicity and for not using regex (i just don't like using them!)

Answer 22

 function substrCount( str, x ) {
   let count = -1, pos = 0;
   do {
     pos = str.indexOf( x, pos ) + 1;
     count++;
   } while( pos > 0 );
   return count;
 }

Answer 23

ES2020 offers a new MatchAll which might be of use in this particular context.

Here we create a new RegExp, please ensure you pass 'g' into the function.

Convert the result using Array.from and count the length, which returns 2 as per the original requestor's desired output.

 let strToCheck = RegExp('is', 'g') let matchesReg = "This is a string.".matchAll(strToCheck) console.log(Array.from(matchesReg).length) // 2

Answer 24

A simple way would be to split the string on the required word, the word for which we want to calculate the number of occurences, and subtract 1 from the number of parts:

function checkOccurences(string, word) {
      return string.split(word).length - 1;
}
const text="Let us see. see above, see below, see forward, see backward, see left, see right until we will be right"; 
const count=countOccurences(text,"see "); // 2

Answer 25

We can use the js split function, and it's length minus 1 will be the number of occurrences.

var temp = "This is a string.";
alert(temp.split('is').length-1);

Answer 26

Here is my solution. I hope it would help someone

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

Answer 27

 var countInstances = function(body, target) { var globalcounter = 0; var concatstring = ''; for(var i=0,j=target.length;i<body.length;i++){ concatstring = body.substring(i-1,j); if(concatstring === target){ globalcounter += 1; concatstring = ''; } } return globalcounter; }; console.log( countInstances('abcabc', 'abc') ); // ==> 2 console.log( countInstances('ababa', 'aba') ); // ==> 2 console.log( countInstances('aaabbb', 'ab') ); // ==> 1

Answer 28

A little late but, assuming we have the following string:

var temp = "This is a string.";

First we split on whatever you are looking to match, this will return an array of strings.

var array = temp.split("is");

Then we get the length of it and subtract 1 to it since split defaults to an array of size 1 and by consequence increments its size every-time it finds an occurrence.

var occurrenceCount = array.length - 1;
alert(occurrenceCount); //should output '2'

You can also do all this in one line as follows:

alert("This is a string.".split("is").length - 1); //should output '2'

Hope it helps :D

Answer 29

This solution is based on the .replace() method that accept a RegEx as first parameter and a function as second parameter that we can use as a closure to increment a counter...

/**
 * Return the frequency of a substring in a string
 * @param {string} string - The string.
 * @param {string} string - The substring to count.
 * @returns {number} number - The frequency.
 * 
 * @author Drozerah https://gist.github.com/Drozerah/2b8e08d28413d66c3e63d7fce80994ce
 * @see https://stackoverflow.com/a/55670859/9370788
 */
const subStringCounter = (string, subString) => {

    let count = 0
    string.replace(new RegExp(subString, 'gi'), () => count++)
    return count
}

Usage

subStringCounter("foofoofoo", "bar"); //0

subStringCounter("foofoofoo", "foo"); //3

Answer 30

came across this post.

let str = 'As sly as a fox, as strong as an ox';

let target = 'as'; // let's look for it

let pos = 0;
while (true) {
  let foundPos = str.indexOf(target, pos);
  if (foundPos == -1) break;

  alert( `Found at ${foundPos}` );
  pos = foundPos + 1; // continue the search from the next position
}

The same algorithm can be layed out shorter:

let str = "As sly as a fox, as strong as an ox";
let target = "as";

let pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
  alert( pos );
}

Answer 31

---

substr_count translated to Javascript from php

---

• Locutus (Package that translates Php to JS)
• substr_count (official page, code copied below)

function substr_count (haystack, needle, offset, length) { 
  // eslint-disable-line camelcase
  //  discuss at: https://locutus.io/php/substr_count/
  // original by: Kevin van Zonneveld (https://kvz.io)
  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Thomas
  //   example 1: substr_count('Kevin van Zonneveld', 'e')
  //   returns 1: 3
  //   example 2: substr_count('Kevin van Zonneveld', 'K', 1)
  //   returns 2: 0
  //   example 3: substr_count('Kevin van Zonneveld', 'Z', 0, 10)
  //   returns 3: false

  var cnt = 0

  haystack += ''
  needle += ''
  if (isNaN(offset)) {
    offset = 0
  }
  if (isNaN(length)) {
    length = 0
  }
  if (needle.length === 0) {
    return false
  }
  offset--

  while ((offset = haystack.indexOf(needle, offset + 1)) !== -1) {
    if (length > 0 && (offset + needle.length) > length) {
      return false
    }
    cnt++
  }

  return cnt
}

Check out Locutus's Translation Of Php's substr_count function

Answer 32

你可以试试这个

let count = s.length - s.replace(/is/g, "").length;

Answer 33

The parameters: ustring: the superset string countChar: the substring

A function to count substring occurrence in JavaScript:

 function subStringCount(ustring, countChar){ var correspCount = 0; var corresp = false; var amount = 0; var prevChar = null; for(var i=0; i!=ustring.length; i++){ if(ustring.charAt(i) == countChar.charAt(0) && corresp == false){ corresp = true; correspCount += 1; if(correspCount == countChar.length){ amount+=1; corresp = false; correspCount = 0; } prevChar = 1; } else if(ustring.charAt(i) == countChar.charAt(prevChar) && corresp == true){ correspCount += 1; if(correspCount == countChar.length){ amount+=1; corresp = false; correspCount = 0; prevChar = null; }else{ prevChar += 1 ; } }else{ corresp = false; correspCount = 0; } } return amount; } console.log(subStringCount('Hello World, Hello World', 'll'));

Answer 34

 var str = 'stackoverflow'; var arr = Array.from(str); console.log(arr); for (let a = 0; a <= arr.length; a++) { var temp = arr[a]; var c = 0; for (let b = 0; b <= arr.length; b++) { if (temp === arr[b]) { c++; } } console.log(`the ${arr[a]} is counted for ${c}`) }

Answer 35

Iterate less the second time (just when first letter of substring matches) but still uses 2 for loops:

   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"));

Answer 36

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

Answer 37

var mystring = 'This is the lorel ipsum text';
var mycharArray = mystring.split('');
var opArr = [];
for(let i=0;i<mycharArray.length;i++){
if(mycharArray[i]=='i'){//match the character you want to match
    opArr.push(i);
  }}
console.log(opArr); // it will return matching index position
console.log(opArr.length); // it will return length

Answer 38

const getLetterMatchCount = (guessedWord, secretWord) => {
  const secretLetters = secretWord.split('');
  const guessedLetterSet = new Set(guessedWord);
  return secretLetters.filter(letter => guessedLetterSet.has(letter)).length;
};
const str = "rahul";
const str1 = "rajendra";

getLetterMatchCount(str, str1)

Answer 39

function substringFrequency(string , substring){
    let index = string.indexOf(substring)
    let occurenceFrequency  = 0
    for (let i=0 ; i < string.length  ; i++){
        if (index != -1){
            occurenceFrequency ++
            index = string.indexOf(substring , index+1)
        }else{
            break
        } 
       }
    return (occurenceFrequency)
}

Answer 40

Here is my solution, in 2022, using map() and filter():

string = "Xanthous: A person with yellow hair. Her hair was very xanthous in colour."       
count = string.split('').map((e,i) => { if(e === 'e') return i;}).filter(Boolean).length

Just for the fun of using these functions. The example counts the number of "e" in my string.

This is the same as using the match() function:

(string.match(/e/g)||[]).length

or simply the split() function:

string.split('e').length - 1

I think the best is to use match(), because it consumes less resources! My answer is just for fun and to show that there are many possibilities to solve this problem

Answer 41

added this optimization:

How to count string occurrence in string?

This is probably the fastest implementation here, but it would be even faster if you replaced "++pos" with "pos+=searchFor.length" – hanshenrik

function occurrences(str_, subStr) {
  let occurence_count = 0
  let pos = -subStr.length
  while ((pos = str_.indexOf(subStr, pos + subStr.length)) > -1) {
    occurence_count++
  }
  return occurence_count
}

Answer 42

How can I count the number of times a particular string occurs in another string. For example, this is what I am trying to do in Javascript:

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

Answer 43

Try this:

function countString(str, search){
    var count=0;
    var index=str.indexOf(search);
    while(index!=-1){
        count++;
        index=str.indexOf(search,index+1);
    }
    return count;
}

Answer 44

 var s = "1";replaced word var a = "HRA"; //have to replace var str = document.getElementById("test").innerHTML; var count = str.split(a).length - 1; for (var i = 0; i < count; i++) { var s = "1"; var a = "HRA"; var str = document.getElementById("test").innerHTML; var res = str.replace(a, s); document.getElementById("test").innerHTML = res; } 

 <input " type="button" id="Btn_Validate" value="Validate" class="btn btn-info" /> <div class="textarea" id="test" contenteditable="true">HRABHRA</div>