Wie zählt das Auftreten von Zeichenfolgen in Zeichenfolgen?

Wie kann ich zählen, wie oft eine bestimmte Zeichenfolge in einer anderen Zeichenfolge vorkommt? Zum Beispiel versuche ich Folgendes in Javascript zu tun:

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

Der greguläre Ausdruck (kurz für global ) besagt, dass die gesamte Zeichenfolge durchsucht werden soll, anstatt nur das erste Vorkommen zu finden. Das passt iszweimal zusammen:

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

Und wenn es keine Übereinstimmungen gibt, wird Folgendes zurückgegeben 0:

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

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

Verwendungszweck

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

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

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

allowOverlapping

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

Streichhölzer:

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

Gerätetest

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

Benchmark

Ich habe einen Benchmark-Test durchgeführt und meine Funktion ist mehr als zehnmal schneller als die von gumbo veröffentlichte Regexp-Match-Funktion. In meinem Teststring ist 25 Zeichen lang. mit 2 Vorkommen des Zeichens 'o'. Ich habe 1 000 000 Mal in Safari ausgeführt.

Safari 5.1

Benchmark> Gesamtzeitausführung: 5617 ms (regulärer Ausdruck)

Benchmark> Gesamtzeitausführung: 881 ms (meine Funktion 6,4x schneller)

Firefox 4

Benchmark> Gesamtzeitausführung: 8547 ms (Rexexp)

Benchmark> Gesamtzeitausführung: 634 ms (meine Funktion 13,5x schneller)

---

Bearbeiten: Änderungen, die ich vorgenommen habe

• Länge des zwischengespeicherten Teilstrings

• Typ-Casting zum String hinzugefügt.

• optionaler Parameter 'allowOverlapping' hinzugefügt

• Die korrekte Ausgabe für den leeren Teilstring-Fall wurde behoben.

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

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

Sie können dies versuchen:

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

Meine Lösung:

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

Sie können verwenden match, um eine solche Funktion zu definieren:

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

Die Nicht-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

Nur Code-Golf Rebecca Chernoff ‚s Lösung :-)

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

String.prototype.Count = function (find) {
    return this.split(find).length - 1;
}

console.log("This is a string.".Count("is"));

Dies wird 2 zurückgeben.

Hier ist die schnellste Funktion!

Warum ist es schneller?

• Überprüft nicht char für char (mit 1 Ausnahme)
• Verwendet eine Weile und erhöht 1 var (die Zeichenanzahl var) gegenüber einer for-Schleife, die die Länge überprüft und 2 vars erhöht (normalerweise var i und eine var mit der Zeichenanzahl).
• Verwendet viel weniger Vars
• Verwendet keinen regulären Ausdruck!
• Verwendet eine (hoffentlich) hochoptimierte Funktion

• Alle Vorgänge sind so kombiniert wie möglich, um Verlangsamungen aufgrund mehrerer Vorgänge zu vermeiden

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

Hier ist eine langsamere und besser lesbare 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;
    };

Dieser ist langsamer wegen des Zählers, der langen Variablennamen und des Missbrauchs von 1 Var.

Um es zu benutzen, machen Sie einfach folgendes:

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

Bearbeiten: (16.12.2013)

NICHT mit Opera 12.16 oder älter verwenden! Es dauert fast 2,5x mehr als die Regex-Lösung!

Auf Chrom dauert diese Lösung zwischen 14 ms und 20 ms für 1.000.000 Zeichen.

Die Regex-Lösung benötigt 11-14 ms für die gleiche Menge.

Die Verwendung einer Funktion (außerhalb String.prototype) dauert ca. 10-13 ms.

Hier ist der verwendete Code:

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

Das Ergebnis aller Lösungen sollte 100.000 sein!

Hinweis: Wenn diese Funktion mehr als 1 Zeichen zählen soll, ändern Sie die Position c=(c+'')[0]inc=c+''

Ich denke, der Zweck von Regex unterscheidet sich stark von indexOf. indexOfFinden Sie einfach das Vorkommen einer bestimmten Zeichenfolge, während Sie in Regex Platzhalter verwenden können, [A-Z]was bedeutet, dass jedes Großbuchstaben im Wort gefunden wird, ohne das tatsächliche Zeichen anzugeben .

Beispiel:

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

Super duper alt, aber ich musste heute so etwas machen und dachte nur daran, SO danach zu überprüfen. Funktioniert ziemlich schnell für mich.

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

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

Siehe: - Zählen Sie einen Teilstring, der in der Zeichenfolge angezeigt wird, um eine schrittweise Erklärung zu erhalten.

Aufbauend auf der obigen Antwort von @ Vittim.us. Ich mag die Kontrolle, die mir seine Methode gibt und die es einfach macht, sie zu erweitern, aber ich musste Groß- und Kleinschreibung nicht berücksichtigen und Übereinstimmungen auf ganze Wörter beschränken, um die Interpunktion zu unterstützen. (zB "Bad" ist in "Bad nehmen", aber nicht "Baden")

Der reguläre Satzzeichen für Interpunktion stammt von: https://stackoverflow.com/a/25575009/497745 ( Wie kann ich mit Regex alle Satzzeichen aus einem String in JavaScript entfernen? )

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

Bitte zögern Sie nicht, diese Antwort zu ändern und umzugestalten, wenn Sie Fehler oder Verbesserungen entdecken.

Beachten Sie für alle, die diesen Thread in Zukunft finden, dass die akzeptierte Antwort nicht immer den richtigen Wert zurückgibt, wenn Sie ihn verallgemeinern, da er Regex-Operatoren wie $und erstickt .. Hier ist eine bessere Version, die mit jeder Nadel umgehen kann :

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

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

Verwenden Sie get_occurrence (varS, string), um das Auftreten von Zeichen und Zeichenfolgen in einer Zeichenfolge zu ermitteln.

Versuch es

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

Einfache Version ohne Regex:

var temp = "This is a string.";

var count = (temp.split('is').length - 1);

alert(count);

Niemand wird das jemals sehen, aber es ist gut, ab und zu Rekursions- und Pfeilfunktionen zurückzubringen (Wortspiel herrlich beabsichtigt)

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

Versuche dies

let allData =  "This is a string.";
let searchString = 'is';
let regularExp = new RegExp(searchString, 'g');
let occurArray = allData.match(regularExp);
let count = (occurArray || []).length;
alert(count); 

Fiddle Link: https://jsfiddle.net/rajaramtt/gn0dtsjc/1/

Dies ist ein sehr alter Thread, auf den ich gestoßen bin, aber da viele ihre Antworten gepusht haben, ist hier meiner in der Hoffnung, jemandem mit diesem einfachen Code zu helfen.

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

Ich bin mir nicht sicher, ob es die schnellste Lösung ist, aber ich habe es der Einfachheit halber und weil ich keinen regulären Ausdruck verwende (ich mag es einfach nicht, sie zu verwenden!).

Diese Funktion gibt die Anzahl der Vorkommen eines Wortes im Text zurück.

Beachten Sie, dass wir toLowerCase verwenden, um die Anzahl der Vorkommen unabhängig vom Format (Groß- und Kleinschreibung ...) des Wortes und des Textes zu berechnen

wordCount(text, word) {
    if (!text || !word) {
      return 0;
    }
    text = text.toLowerCase();
    word = word.toLowerCase();
    return ( text.split( word ).length - 1 );
}

Antwort für Leandro Batista: Nur ein Problem mit dem regulären Ausdruck.

 "use strict";
 var dataFromDB = "testal";
 
  $('input[name="tbInput"]').on("change",function(){
	var charToTest = $(this).val();
	var howManyChars = charToTest.length;
	var nrMatches = 0;
	if(howManyChars !== 0){
		charToTest = charToTest.charAt(0);
		var regexp = new RegExp(charToTest,'gi');
		var arrMatches = dataFromDB.match(regexp);
		nrMatches = arrMatches ? arrMatches.length : 0;
	}
		$('#result').html(nrMatches.toString());

  });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="main">
What do you wanna count <input type="text" name="tbInput" value=""><br />
Number of occurences = <span id="result">0</span>
</div>

Ein bisschen spät, aber vorausgesetzt, wir haben die folgende Zeichenfolge:

var temp = "This is a string.";

Zuerst teilen wir uns auf, was auch immer Sie suchen, dies wird eine Reihe von Zeichenfolgen zurückgeben.

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

Dann erhalten wir die Länge und subtrahieren 1 davon, da split standardmäßig ein Array der Größe 1 verwendet und folglich seine Größe jedes Mal erhöht, wenn es ein Vorkommen findet.

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

Sie können dies auch in einer Zeile wie folgt tun:

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

Hoffe es hilft: D.

Diese Lösung basiert auf der .replace()Methode, die eine RegEx als ersten Parameter und eine Funktion als zweiten Parameter akzeptiert , die wir als Abschluss zum Inkrementieren eines Zählers verwenden können ...

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

Verwendungszweck

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

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

bin auf diesen Beitrag gestoßen.

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
}

Der gleiche Algorithmus kann kürzer angelegt werden:

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

substr_count übersetzt nach Javascript von PHP

• Locutus (Paket, das Php in JS übersetzt)
• substr_count (offizielle Seite, Code unten kopiert)

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
}

Schauen Sie sich Locutus 'Übersetzung der Funktion substr_count von Php an

Versuche dies:

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