Ich muss die Anzahl der Vorkommen eines Zeichens in einer Zeichenfolge zählen.

Angenommen, meine Zeichenfolge enthält:

var mainStr = "str1,str2,str3,str4";

Ich möchte die Anzahl der Kommazeichen ermitteln ,, die 3 beträgt. Und die Anzahl der einzelnen Zeichenfolgen nach der Aufteilung entlang des Kommas, die 4 beträgt.

Ich muss auch überprüfen, ob jede der Zeichenfolgen, dh str1 oder str2 oder str3 oder str4, beispielsweise 15 Zeichen nicht überschreiten darf.

Ich habe diese Antwort aktualisiert. Ich mag die Idee, ein Match besser zu verwenden, aber es ist langsamer:

console.log(("str1,str2,str3,str4".match(/,/g) || []).length); //logs 3

console.log(("str1,str2,str3,str4".match(new RegExp("str", "g")) || []).length); //logs 4

jsfiddle

Verwenden Sie ein Literal für reguläre Ausdrücke, wenn Sie vorher wissen, wonach Sie suchen. Wenn nicht, können Sie den RegExpKonstruktor verwenden und das gFlag als Argument übergeben.

matchkehrt nullohne Ergebnisse zurück, also die|| []

Die ursprüngliche Antwort, die ich 2009 gegeben habe, ist unten. Es wird unnötig ein Array erstellt, aber die Verwendung eines Split ist schneller (Stand September 2014). Ich bin ambivalent, wenn ich die Geschwindigkeit wirklich brauchte, würde es keine Frage geben, dass ich einen Split verwenden würde, aber ich würde es vorziehen, Match zu verwenden.

Alte Antwort (von 2009):

Wenn Sie nach Kommas suchen:

(mainStr.split(",").length - 1) //3

Wenn Sie nach der str suchen

(mainStr.split("str").length - 1) //4

Sowohl in der Antwort von @ Lo als auch in meinem eigenen albernen jsperf-Test- Split kommt die Geschwindigkeit voran, zumindest in Chrome, aber das Erstellen des zusätzlichen Arrays scheint einfach nicht vernünftig zu sein.

Es gibt mindestens vier Möglichkeiten. Die beste Option, die auch für die native RegEx-Engine am schnellsten sein sollte, befindet sich oben. jsperf.com ist derzeit nicht verfügbar, andernfalls würde ich Ihnen Leistungsstatistiken zur Verfügung stellen.

Update : Bitte finden Sie die Leistungstests hier und führen Sie sie selbst aus, um Ihre Leistungsergebnisse beizutragen. Die Einzelheiten der Ergebnisse werden später angegeben.

1.

 ("this is foo bar".match(/o/g)||[]).length
 //>2

2.

"this is foo bar".split("o").length-1
 //>2

Split nicht empfohlen. Ressourcenhungrig. Weist jeder Übereinstimmung neue Instanzen von 'Array' zu. Versuchen Sie das nicht für eine Datei mit> 100 MB über FileReader. Mit der Profiler- Option von Chrome können Sie die EXACT-Ressourcennutzung tatsächlich leicht beobachten .

3.

var stringsearch = "o"
   ,str = "this is foo bar";
for(var count=-1,index=-2; index != -1; count++,index=str.indexOf(stringsearch,index+1) );
 //>count:2

4.

Suche nach einem einzelnen Zeichen

var stringsearch = "o"
   ,str = "this is foo bar";
for(var i=count=0; i<str.length; count+=+(stringsearch===str[i++]));
 //>count:2

Aktualisieren:

5.

Elementzuordnung und -filterung, aufgrund der allgemeinen Ressourcenvorbelegung nicht empfohlen, anstatt Python-Generatoren zu verwenden.

var str = "this is foo bar"
str.split('').map( function(e,i){ if(e === 'o') return i;} )
             .filter(Boolean)
//>[9, 10]
[9, 10].length
//>2

Teilen: Ich habe diesen Kern mit derzeit 8 Methoden zum Zählen von Charakteren erstellt, damit wir unsere Ideen direkt bündeln und teilen können - nur zum Spaß und vielleicht einige interessante Benchmarks :)

https://gist.github.com/2757250

Fügen Sie diese Funktion dem Stachelprototyp hinzu:

String.prototype.count=function(c) { 
  var result = 0, i = 0;
  for(i;i<this.length;i++)if(this[i]==c)result++;
  return result;
};

Verwendungszweck:

console.log("strings".count("s")); //2

Eine schnelle Google- Suche ergab dies (von http://www.codecodex.com/wiki/index.php?title=Count_the_number_of_occurrences_of_a_specific_character_in_a_string#JavaScript )

String.prototype.count=function(s1) { 
    return (this.length - this.replace(new RegExp(s1,"g"), '').length) / s1.length;
}

Verwenden Sie es so:

test = 'one,two,three,four'
commas = test.count(',') // returns 3

Verwenden Sie einfach die Aufteilung , um die Anzahl der Vorkommen eines Zeichens in einer Zeichenfolge zu ermitteln.

mainStr.split(',').length // gibt 4 an, was die Anzahl der Zeichenfolgen nach dem Teilen mit einem Trennzeichen ist.

mainStr.split(',').length - 1 // gibt 3 an, was die Anzahl der Kommas ist

Hier ist eine ähnliche Lösung, die jedoch verwendet wird Array.prototype.reduce

function countCharacters(char, string) {
  return string.split('').reduce((acc, ch) => ch === char ? acc + 1: acc, 0)
}

Wie bereits erwähnt, String.prototype.splitfunktioniert viel schneller als String.prototype.replace.

Ich habe festgestellt, dass der beste Ansatz für die Suche nach einem Zeichen in einer sehr großen Zeichenfolge (die beispielsweise 1 000 000 Zeichen lang ist) die Verwendung der replace()Methode ist.

window.count_replace = function (str, schar) {
    return str.length - str.replace(RegExp(schar), '').length;
};

Sie können eine weitere JSPerf- Suite sehen, um diese Methode zusammen mit anderen Methoden zum Suchen eines Zeichens in einer Zeichenfolge zu testen.

Sie können Ihre Zeichenfolge auch ausruhen und wie ein Array von Elementen damit arbeiten

• Array.prototype.filter ()

const mainStr = 'str1,str2,str3,str4';
const commas = [...mainStr].filter(l => l === ',').length;

console.log(commas);

Oder

• Array.prototype.reduce ()

const mainStr = 'str1,str2,str3,str4';
const commas = [...mainStr].reduce((a, c) => c === ',' ? ++a : a, 0);

console.log(commas);

Ich habe die akzeptierte Antwort leicht verbessert. Sie ermöglicht die Überprüfung der Übereinstimmung zwischen Groß- und Kleinschreibung und ist eine Methode, die an das Zeichenfolgenobjekt angehängt ist:

String.prototype.count = function(lit, cis) {
    var m = this.toString().match(new RegExp(lit, ((cis) ? "gi" : "g")));
    return (m != null) ? m.length : 0;
}

lit ist die Zeichenfolge, nach der gesucht werden soll (z. B. 'ex'), und cis ist Groß- und Kleinschreibung, standardmäßig false, und ermöglicht die Auswahl von Übereinstimmungen ohne Berücksichtigung der Groß- und Kleinschreibung.

var amount_of_os = 'I love StackOverflow.com'.count('o');

amount_of_os wäre gleich 2 .

var amount_of_os = 'I love StackOverflow.com'.count('o', true);

Diesmal amount_of_oswäre gleich 3, da das Kapital Oaus der Zeichenfolge in die Suche einbezogen wird.

ok, ein anderer mit regulärem Ausdruck - wahrscheinlich nicht schnell, aber kurz und besser lesbar als andere, in meinem Fall nur um '_'zu zählen

key.replace(/[^_]/g,'').length

Entfernen Sie einfach alles, was nicht wie Ihr Zeichen aussieht, aber mit einer Zeichenfolge als Eingabe nicht gut aussieht

Leistung von Split vs RegExp

var i = 0;

var split_start = new Date().getTime();
while (i < 30000) {
  "1234,453,123,324".split(",").length -1;
  i++;
}
var split_end = new Date().getTime();
var split_time = split_end - split_start;


i= 0;
var reg_start = new Date().getTime();
while (i < 30000) {
  ("1234,453,123,324".match(/,/g) || []).length;
  i++;
}
var reg_end = new Date().getTime();
var reg_time = reg_end - reg_start;

alert ('Split Execution time: ' + split_time + "\n" + 'RegExp Execution time: ' + reg_time + "\n");

Der einfachste Weg, den ich herausgefunden habe ...

Beispiel-

str = 'mississippi';

function find_occurences(str, char_to_count){
    return str.split(char_to_count).length - 1;
}

find_occurences(str, 'i') //outputs 4

Ich arbeitete an einem kleinen Projekt, für das ein Sub-String-Zähler erforderlich war. Die Suche nach den falschen Sätzen brachte mir keine Ergebnisse, aber nachdem ich meine eigene Implementierung geschrieben hatte, bin ich auf diese Frage gestoßen. Wie auch immer, hier ist mein Weg, es ist wahrscheinlich langsamer als die meisten hier, könnte aber für jemanden hilfreich sein:

function count_letters() {
var counter = 0;

for (var i = 0; i < input.length; i++) {
    var index_of_sub = input.indexOf(input_letter, i);

    if (index_of_sub > -1) {
        counter++;
        i = index_of_sub;
    }
}

http://jsfiddle.net/5ZzHt/1/

Bitte lassen Sie mich wissen, wenn Sie feststellen, dass diese Implementierung fehlschlägt oder einige Standards nicht befolgt! :) :)

UPDATE Möglicherweise möchten Sie Folgendes ersetzen:

    for (var i = 0; i < input.length; i++) {

Mit:

for (var i = 0, input_length = input.length; i < input_length; i++) {

Interessante Lektüre über das Obige: http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

Wenn Sie lodash verwenden, führt die _.countBy- Methode Folgendes aus :

_.countBy("abcda")['a'] //2

Diese Methode funktioniert auch mit Array:

_.countBy(['ab', 'cd', 'ab'])['ab'] //2

Hier ist meine Lösung. Viele Lösungen wurden bereits vor mir veröffentlicht. Aber ich liebe es, meine Ansicht hier zu teilen.

const mainStr = 'str1,str2,str3,str4';

const commaAndStringCounter = (str) => {
  const commas = [...str].filter(letter => letter === ',').length;
  const numOfStr = str.split(',').length;

  return `Commas: ${commas}, String: ${numOfStr}`;
}

// Run the code
console.log(commaAndStringCounter(mainStr)); // Output: Commas: 3, String: 4

Hier finden Sie meine REPL

Die schnellste Methode scheint über den Indexoperator zu sein:

function charOccurances (str, char)
{
  for (var c = 0, i = 0, len = str.length; i < len; ++i)
  {
    if (str[i] == char)
    {
      ++c;
    }
  }
  return c;
}

console.log( charOccurances('example/path/script.js', '/') ); // 2

Oder als Prototypfunktion:

String.prototype.charOccurances = function (char)
{
  for (var c = 0, i = 0, len = this.length; i < len; ++i)
  {
    if (this[i] == char)
    {
      ++c;
    }
  }
  return c;
}

console.log( 'example/path/script.js'.charOccurances('/') ); // 2

Im Folgenden wird ein regulärer Ausdruck verwendet, um die Länge zu testen. testex stellt sicher, dass Sie nicht 16 oder mehr aufeinanderfolgende Nicht-Komma-Zeichen haben. Wenn es den Test besteht, wird die Zeichenfolge aufgeteilt. Das Zählen der Kommas ist so einfach wie das Zählen der Token minus eins.

var mainStr = "str1,str2,str3,str4";
var testregex = /([^,]{16,})/g;
if (testregex.test(mainStr)) {
  alert("values must be separated by commas and each may not exceed 15 characters");
} else {
  var strs = mainStr.split(',');
  alert("mainStr contains " + strs.length + " substrings separated by commas.");
  alert("mainStr contains " + (strs.length-1) + " commas.");
}

s = 'dir/dir/dir/dir/'
for(i=l=0;i<s.length;i++)
if(s[i] == '/')
l++

Was ist mit string.split (gewünschterCharecter) .length-1

Beispiel:

var str = "hellow wie ist das Leben"; var len = str.split ("h"). length-1; gibt die Zählung 2 für das Zeichen "h" in der obigen Zeichenfolge;

Ich verwende Node.js v.6.0.0 und die schnellste ist die mit dem Index (die dritte Methode in Lo Sauers Antwort).

Der zweite ist:

function count(s, c) {
  var n = 0;
  for (let x of s) {
    if (x == c)
      n++;
  }
  return n;
}

Hier ist eine Methode, die fast so schnell ist wie die Split- und die Replace-Methode, die ein kleines bisschen schneller sind als die Regex-Methode (in Chrome).

var num = 0;
for (ch of "str1,str2,str3,str4")
{
    if (ch === ',') num++;
}

Ich habe gerade einen sehr schnellen und schmutzigen Test auf repl.it mit Node v7.4 durchgeführt. Für ein einzelnes Zeichen ist der Standard für die Schleife am schnellsten:

Etwas Code :

// winner!
function charCount1(s, c) {
    let count = 0;
    c = c.charAt(0); // we save some time here
    for(let i = 0; i < s.length; ++i) {
        if(c === s.charAt(i)) {
            ++count;
        }
    }
    return count;
}

function charCount2(s, c) {
    return (s.match(new RegExp(c[0], 'g')) || []).length;
}

function charCount3(s, c) {
    let count = 0;
    for(ch of s) {
        if(c === ch) {
            ++count;
        }
    }
    return count;
}

function perfIt() {
    const s = 'Hello, World!';
    const c = 'o';

    console.time('charCount1');
    for(let i = 0; i < 10000; i++) {
        charCount1(s, c);
    }
    console.timeEnd('charCount1');

    console.time('charCount2');
    for(let i = 0; i < 10000; i++) {
        charCount2(s, c);
    }
    console.timeEnd('charCount2');

    console.time('charCount3');
    for(let i = 0; i < 10000; i++) {
        charCount2(s, c);
    }
    console.timeEnd('charCount3');
}

Ergebnisse einiger Läufe :

 perfIt()
charCount1: 3.843ms
charCount2: 11.614ms
charCount3: 11.470ms
=> undefined
   perfIt()
charCount1: 3.006ms
charCount2: 8.193ms
charCount3: 7.941ms
=> undefined
   perfIt()
charCount1: 2.539ms
charCount2: 7.496ms
charCount3: 7.601ms
=> undefined
   perfIt()
charCount1: 2.654ms
charCount2: 7.540ms
charCount3: 7.424ms
=> undefined
   perfIt()
charCount1: 2.950ms
charCount2: 9.445ms
charCount3: 8.589ms

Und da ist:

function character_count(string, char, ptr = 0, count = 0) {
    while (ptr = string.indexOf(char, ptr) + 1) {count ++}
    return count
}

Funktioniert auch mit ganzen Zahlen!

Meine Lösung:

function countOcurrences(str, value){
   var regExp = new RegExp(value, "gi");
   return str.match(regExp) ? str.match(regExp).length : 0;  
}

Die fünfte Methode in Leo Sauers Antwort schlägt fehl, wenn sich das Zeichen am Anfang der Zeichenfolge befindet. z.B

var needle ='A',
  haystack = 'AbcAbcAbc';

haystack.split('').map( function(e,i){ if(e === needle) return i;} )
  .filter(Boolean).length;

gibt 2 statt 3, weil die Filterfunktion Boolean false für 0 ergibt.

Andere mögliche Filterfunktion:

haystack.split('').map(function (e, i) {
  if (e === needle) return i;
}).filter(function (item) {
  return !isNaN(item);
}).length;

Ich weiß, dass dies eine alte Frage sein könnte, aber ich habe eine einfache Lösung für Anfänger auf niedrigem Niveau in JavaScript.

Als Anfänger konnte ich nur einige der Lösungen für diese Frage verstehen, also habe ich zwei verschachtelte verwendet FOR- Schleifen verwendet, um jedes Zeichen mit jedem anderen Zeichen in der Zeichenfolge zu vergleichen und die Anzahl zu erhöhen Variable für jedes Zeichen gefunden , die diesen Charakter entspricht.

Ich habe ein neues leeres Objekt erstellt, bei dem jeder Eigenschaftsschlüssel ein Zeichen ist und der Wert angibt, wie oft jedes Zeichen in der Zeichenfolge (Anzahl) vorkommt.

Beispielfunktion: -

function countAllCharacters(str) {
  var obj = {};
  if(str.length!==0){
    for(i=0;i<str.length;i++){
      var count = 0;
      for(j=0;j<str.length;j++){
        if(str[i] === str[j]){
          count++;
        }
      }
      if(!obj.hasOwnProperty(str[i])){
        obj[str[i]] = count;
      }
    }
  }
  return obj;
}

Ich glaube, Sie werden feststellen, dass die folgende Lösung sehr kurz, sehr schnell ist, mit sehr langen Zeichenfolgen arbeiten kann, mehrere Zeichensuchen unterstützt, fehlerfrei ist und leere Zeichenfolgensuchen verarbeiten kann.

function substring_count(source_str, search_str, index) {
    source_str += "", search_str += "";
    var count = -1, index_inc = Math.max(search_str.length, 1);
    index = (+index || 0) - index_inc;
    do {
        ++count;
        index = source_str.indexOf(search_str, index + index_inc);
    } while (~index);
    return count;
}

Anwendungsbeispiel:

console.log(substring_count("Lorem ipsum dolar un sit amet.", "m "))

function substring_count(source_str, search_str, index) {
    source_str += "", search_str += "";
    var count = -1, index_inc = Math.max(search_str.length, 1);
    index = (+index || 0) - index_inc;
    do {
        ++count;
        index = source_str.indexOf(search_str, index + index_inc);
    } while (~index);
    return count;
}

Der obige Code behebt den Hauptleistungsfehler in Jakub Wawszczyks, dass der Code auch dann nach einer Übereinstimmung sucht, wenn indexOf angibt, dass es keine gibt und seine Version selbst nicht funktioniert, weil er vergessen hat, die Funktionseingabeparameter anzugeben.

var a = "acvbasbb";
var b= {};
for (let i=0;i<a.length;i++){
    if((a.match(new RegExp(a[i], "g"))).length > 1){
        b[a[i]]=(a.match(new RegExp(a[i], "g"))).length;
    }
}
console.log(b);

In Javascript können Sie den obigen Code verwenden, um das Auftreten eines Zeichens in einer Zeichenfolge zu ermitteln.

Meine Lösung mit ramda js:

const testString = 'somestringtotest'

const countLetters = R.compose(
  R.map(R.length),
  R.groupBy(R.identity),
  R.split('')
)

countLetters(testString)

Link zu REPL.

Die Funktion verwendet die Zeichenfolge str als Parameter und zählt das Auftreten jedes eindeutigen Zeichens in der Zeichenfolge. Das Ergebnis ist ein Schlüssel-Wert-Paar für jedes Zeichen.

var charFoundMap = {};//object defined
    for (var i = 0; i < str.length; i++) {

       if(!charFoundMap[ str[i] ])  {
        charFoundMap[ str[i] ]=1;
       } 
       else
       charFoundMap[ str[i] ] +=1;
       //if object does not contain this 
    }
    return charFoundMap;

}