Zählt die Anzahl der Vorkommen eines Zeichens in einer Zeichenkette in Javascript

Question

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

Nehmen wir zum Beispiel an, meine Zeichenkette enthält:

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

Ich möchte die Anzahl der Kommas ermitteln , Zeichen, also 3, und die Anzahl der einzelnen Zeichenfolgen nach der Trennung durch Komma, also 4.

Außerdem muss ich überprüfen, dass jede der Zeichenketten, d. h. str1 oder str2 oder str3 oder str4, nicht mehr als, sagen wir, 15 Zeichen umfassen sollte.

Answer 1

Sie können auch Rest Ihre Zeichenkette und arbeiten mit ihr wie mit einem Array von Elementen mit

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

Answer 2

Hier ist eine ähnliche Lösung, aber sie verwendet 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.split arbeitet viel schneller als String.prototype.replace .

Answer 3

Wenn Sie lodash verwenden, wird die _.countBy Methode wird dies tun:

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

Diese Methode funktioniert auch mit Array:

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

Answer 4

Ich weiß, dass ich hier zu spät dran bin, aber ich war ziemlich verblüfft, dass niemand diese Frage mit einem einfachen Ansatz beantwortet hat. Ein großer Teil der Antworten, die von der Gemeinschaft für diese Frage zur Verfügung gestellt werden, basieren auf Iteration, aber alle bewegen sich über Zeichenketten auf einer pro-Zeichen-Basis, die nicht wirklich effizient ist.

Bei einer großen Zeichenkette, die Tausende von Zeichen enthält, kann das Überfliegen jedes einzelnen Zeichens, um die Anzahl der Vorkommnisse zu ermitteln, ziemlich überflüssig werden, ganz zu schweigen von einem Code-Geruch. Die folgenden Lösungen nutzen die Vorteile von slice , indexOf und die bewährte traditionelle while Schleife. Auf diese Weise müssen wir nicht jedes einzelne Zeichen durchgehen, und die Zählung der Vorkommen wird erheblich beschleunigt. Sie folgen einer ähnlichen Logik wie Parser und lexikalische Analysatoren, die Stringwalks benötigen.

Verwendung mit Slice

Bei diesem Ansatz nutzen wir slice und mit jedem indexOf Spiel werden wir uns durch die Kette bewegen und die zuvor gesuchten Tränke eliminieren. Jedes Mal, wenn wir indexOf wird die Größe der gesuchten Zeichenfolge kleiner sein.

function countChar (char: string, search: string): number {

  let num: number = 0;
  let str: string = search;
  let pos: number = str.indexOf(char);

  while(pos > -1) {
    str = str.slice(pos + 1);
    pos = str.indexOf(char);
    num++;
  }

  return num;

}

// Call the function
countChar('x', 'foo x bar x baz x') // 3

Verwendung mit IndexOf ab Position

Ähnlich wie bei dem ersten Ansatz mit slice aber anstatt die gesuchte Zeichenkette zu erweitern, wird die from Parameter in indexOf método.

function countChar (char: string, str: string): number {

  let num: number = 0;
  let pos: number = str.indexOf(char);

  while(pos > -1) {
    pos = str.indexOf(char, pos + 1);
    num++;
  }

  return num;

}

// Call the function
countChar('x', 'foo x bar x baz x') // 3

Ich persönlich ziehe den zweiten Ansatz dem ersten vor, aber beide sind gut und leistungsfähig, wenn es um große, aber auch um kleinere Zeichenketten geht.

Answer 5

Ok, eine andere mit regexp - wahrscheinlich nicht schnell, aber kurz und besser lesbar als andere, in meinem Fall nur '_' zu zählen

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

Entfernen Sie einfach alles, was nicht wie Ihr Zeichen aussieht aber es sieht nicht gut aus mit einem String als Eingabe