Compter le nombre d'occurrences d'un caractère dans une chaîne de caractères en Javascript

J'ai mis à jour cette réponse. J'aime l'idée de l'utilisation d'un match de mieux, mais il est plus lent:

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

Utiliser une expression régulière littérale si vous savez ce que vous cherchez à l'avance, si non, vous pouvez utiliser le RegExp constructeur, et de passer dans le g drapeau comme un argument.

match retourne null sans résultats donc la || []

L'original de la réponse que j'ai faite en 2009 est ci-dessous. Il crée un tableau inutilement, mais l'aide d'une scission est plus rapide (à compter de septembre 2014). Je suis ambivalent, si j'ai vraiment besoin de la vitesse il n'y aurait pas de question que je voudrais utiliser un split, mais je préfère utiliser la correspondance.

Vieille réponse (à partir de 2009):

Si vous êtes à la recherche pour les virgules:

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

Si vous êtes à la recherche pour le str

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

À la fois dans @Lo réponse et dans mon idiot jsperf test split vient d'avance à la vitesse, au moins dans Chrome, mais encore de la création de la collection supplémentaire ne semble tout simplement pas sain d'esprit.

Ajouter cette fonction à sting prototype :

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

utilisation:

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

Simplement, utiliser le split pour trouver le nombre d'occurrences d'un caractère dans une chaîne.

mainStr.split(',').length //donne 4, qui est le nombre de chaînes après fractionnement à l'aide de séparateur virgule

mainStr.split(',').length - 1 //donne 3, qui est le nombre de virgule

Voici une solution similaire, mais il utilise Array.ptototype.reduce

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

Comme il a été mentionné, String.prototype.split fonctionne beaucoup plus rapidement que String.prototype.replace.

Performance de Split vs RegExp

JS:

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

Je travaille sur un petit projet qui a exigé une sous-chaîne de contre. La recherche pour le mal de phrases m'ont fourni aucun résultat, cependant après avoir écrit ma propre mise en œuvre, j'ai trébuché sur cette question. De toute façon, ici, c'est mon chemin, il est probablement plus lent que la plupart ici, mais pourrait être utile à quelqu'un:

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/

S'il vous plaît laissez-moi savoir si vous trouvez cette mise en œuvre d'échouer ou de ne pas suivre certaines normes! 🙂

Mise à JOUR
Vous pouvez remplacer:

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

Avec:

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

Lecture intéressante à discuter de ce qui précède:
http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

Vous pouvez également reste votre chaîne et de travailler avec elle comme un tableau d'éléments à l'aide de

• Tableau.le prototype.filtre()

JS:

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

console.log(commas);

Ou

• Tableau.le prototype.réduire()

JS:

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

console.log(commas);

Voici ma solution. Beaucoup de solution déjà posté avant moi. Mais j'aime partager mon point de vue ici.

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

Vous trouverez ici mes REPL

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

Je suis en utilisant Node.js v. 6.0.0 et la plus rapide est l'un avec de l'index (la 3ème méthode dans Lo Sauer réponse).

La seconde est:

JS:

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

J'ai juste fait une très rapide et sale de test sur repl.il l'aide d'un Noeud v7.4. Pour un seul personnage, le standard pour la boucle est la plus rapide:

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

Résultats de quelques pistes de:

 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

Ma solution:

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

Je sais que cela peut être une vieille question, mais j'ai une solution simple pour un faible niveau niveau débutant en JavaScript.

En tant que débutant, je ne pouvais comprendre certaines des solutions à cette question, j'ai donc utilisé deux imbriqués POUR boucles de vérifier chaque personnage contre tous les autres caractères d'une chaîne, incrémentation d'une compter variable pour chaque caractère qui est égale à celle des caractères.

J'ai créé un nouvel objet vide où chaque propriété clé est d'un caractère et la valeur est le nombre de fois que chaque personnage est apparu dans la chaîne(le comte).

Exemple la fonction de:-

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

La méthode la plus rapide semble être via l'index de l'opérateur:

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

Utilisation:

charOccurances('example/path/script.js', '/') == 2

Ou comme un prototype de la fonction:

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

Utilisation:

charOccurances('example/path/script.js', '/') == 2

Ma solution avec ramda js:

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

Lien vers REPL.

JS:

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