Muszę policzyć liczbę wystąpień znaku w ciągu.

Załóżmy na przykład, że mój ciąg zawiera:

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

Chcę znaleźć liczbę ,znaków przecinka , która wynosi 3. I liczbę pojedynczych ciągów po podziale wzdłuż przecinka, czyli 4.

Muszę również sprawdzić, czy każdy z łańcuchów, tj. Str1 lub str2 lub str3 lub str4, nie powinien przekraczać, powiedzmy, 15 znaków.

Zaktualizowałem tę odpowiedź. Podoba mi się pomysł lepszego dopasowania, ale jest wolniejszy:

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

Użyj literału wyrażenia regularnego, jeśli wiesz, czego szukasz, jeśli nie, możesz użyć RegExpkonstruktora i przekazać gflagę jako argument.

matchzwraca nullbez żadnych wyników, więc|| []

Oryginalna odpowiedź, którą udzieliłem w 2009 roku, jest poniżej. Tworzy tablicę niepotrzebnie, ale użycie podziału jest szybsze (od września 2014 r.). Jestem ambiwalentny, gdybym naprawdę potrzebował prędkości, nie byłoby wątpliwości, że użyłbym podziału, ale wolałbym użyć dopasowania.

Stara odpowiedź (z 2009 r.):

Jeśli szukasz przecinków:

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

Jeśli szukasz str

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

Zarówno w odpowiedzi @ Lo, jak i w moim głupim podziale testu jsperf pojawia się szybko, przynajmniej w Chrome, ale znowu tworzenie dodatkowej tablicy po prostu nie wydaje się rozsądne.

Istnieją co najmniej cztery sposoby. Najlepsza opcja, która powinna być również najszybsza - dzięki natywnemu silnikowi RegEx - - znajduje się na górze. Witryna jsperf.com jest obecnie niedostępna, w przeciwnym razie przedstawiłbym statystyki wydajności.

Aktualizacja : znajdź tutaj testy wydajnościi sam je uruchom, aby przyczynić się do uzyskania wyników. Szczegóły wyników zostaną podane później.

1.

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

2)

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

podział nie jest zalecany. Głodny zasobów. Przypisuje nowe wystąpienia „Array” dla każdego dopasowania. Nie próbuj tego w przypadku pliku> 100 MB przez FileReader. Możesz naprawdę łatwo obserwować zużycie zasobów DOKŁADNIE, korzystając z opcji profilera Chrome .

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

szukanie jednego znaku

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

Aktualizacja:

5

mapowanie i filtrowanie elementów, niezalecane ze względu na ogólną wstępną alokację zasobów zamiast używania Pythonowskich „generatorów”

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

Podziel się: Zrobiłem to sens , ze obecnie 8 sposobów liczenia znaków, więc możemy bezpośrednio połączyć i podzielić się naszymi pomysłami - tylko dla zabawy, a może kilka interesujących punktów odniesienia :)

https://gist.github.com/2757250

Dodaj tę funkcję do prototypu żądła:

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

stosowanie:

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

Szybka wyszukiwarka Google ma to (z 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;
}

Użyj tego w ten sposób:

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

Wystarczy użyć podziału, aby sprawdzić liczbę wystąpień znaku w ciągu.

mainStr.split(',').length // daje 4, która jest liczbą ciągów znaków po rozdzieleniu za pomocą przecinka

mainStr.split(',').length - 1 // // daje 3, która jest liczbą przecinków

Oto podobne rozwiązanie, ale wykorzystuje Array.prototype.reduce

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

Jak wspomniano, String.prototype.splitdziała znacznie szybciej niż String.prototype.replace.

Odkryłem, że najlepszym podejściem do wyszukiwania znaku w bardzo dużym ciągu (na przykład o długości 1 000 000 znaków) jest użycie tej replace()metody.

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

Możesz zobaczyć jeszcze jeden pakiet JSPerf do testowania tej metody wraz z innymi metodami znajdowania znaku w ciągu.

Możesz także spocząć na swoim ciągu i pracować z nim jak z wykorzystaniem szeregu elementów

• Array.prototype.filter ()

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

console.log(commas);

Lub

• Array.prototype.reduce ()

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

console.log(commas);

Wprowadziłem niewielką poprawę w stosunku do przyjętej odpowiedzi, pozwala ona sprawdzać z rozróżnianiem wielkości liter / bez rozróżniania wielkości liter i jest metodą dołączoną do obiektu łańcucha:

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

lit jest ciągiem do wyszukania (takim jak „ex”), a cis nie rozróżnia wielkości liter, domyślnie false, umożliwi wybór dopasowania bez rozróżniania wielkości liter.

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

amount_of_osbyłoby równe 2.

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

Tym razem amount_of_osbyłby równy 3, ponieważ kapitał Oz ciągu zostaje włączony do wyszukiwania.

ok, inny z regexp - prawdopodobnie nie szybki, ale krótki i lepiej czytelny niż inne, w moim przypadku po prostu '_'liczyć

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

po prostu usuń wszystko, co nie wygląda jak twój char, ale nie wygląda ładnie z ciągiem jako wejściem

Wydajność 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");

Najłatwiejszy sposób, żeby się dowiedzieć ...

Przykład-

str = 'mississippi';

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

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

Pracowałem nad małym projektem, który wymagał licznika podciągów. Poszukiwanie niewłaściwych fraz nie dało mi rezultatów, jednak po napisaniu własnej implementacji natknąłem się na to pytanie. W każdym razie, oto moja droga, prawdopodobnie jest wolniejsza niż większość tutaj, ale może być komuś pomocna:

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/

Daj mi znać, jeśli ta implementacja zakończy się niepowodzeniem lub nie spełnia niektórych standardów! :)

AKTUALIZACJA Możesz zastąpić:

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

Z:

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

Ciekawe lektury omawiające powyższe: http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

Jeśli używasz lodash, metoda _.countBy zrobi to:

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

Ta metoda działa również z tablicą:

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

Oto moje rozwiązanie. Wiele rozwiązań już zostało opublikowanych przede mną. Ale uwielbiam dzielić się tutaj moim poglądem.

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

Tutaj znajdziesz moją REPL

Najszybszą metodą wydaje się być operator indeksu:

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

Lub jako funkcja prototypowa:

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

Poniżej zastosowano wyrażenie regularne do przetestowania długości. Testex zapewnia, że ​​nie masz 16 lub więcej kolejnych znaków bez przecinków. Jeśli przejdzie test, przechodzi do podziału łańcucha. liczenie przecinków jest tak proste, jak liczenie tokenów minus jeden.

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

Co z string.split (pożądanyCharecter) .length-1

Przykład:

var str = "hellow how is life"; var len = str. podświetlony („h”). długość-1; da licznik 2 dla znaku „h” w powyższym ciągu;

Używam Node.js v.6.0.0, a najszybszy jest ten z indeksem (trzecia metoda w odpowiedzi Lo Sauera).

Drugi to:

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

Oto jeden prawie tak szybki, jak metody dzielenia i zastępowania, które są nieco szybsze niż metoda regex (w chrome).

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

Właśnie zrobiłem bardzo szybki i brudny test na repl.it przy użyciu Node v7.4 . W przypadku pojedynczego znaku standard pętli jest najszybszy:

Jakiś kod :

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

Wyniki z kilku przebiegów :

 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

I jest:

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

Działa również z liczbami całkowitymi!

Moje rozwiązanie:

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

Piąta metoda w odpowiedzi Leo Sauersa kończy się niepowodzeniem, jeśli znak znajduje się na początku ciągu. na przykład

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

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

da 2 zamiast 3, ponieważ funkcja filtru Boolean daje wartość false dla 0.

Inne możliwe funkcje filtra:

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

Wiem, że to może być stare pytanie, ale mam proste rozwiązanie dla początkujących na niskim poziomie w JavaScript.

Jako początkujący mogłem zrozumieć tylko niektóre rozwiązania tego pytania, więc użyłem dwóch zagnieżdżonych pętli FOR, aby sprawdzić każdy znak względem każdego innego znaku w ciągu, zwiększając zmienną count dla każdego znalezionego znaku, który jest równy temu znakowi.

Utworzyłem nowy pusty obiekt, w którym każdy klucz właściwości jest znakiem, a wartością jest to, ile razy każdy znak pojawił się w ciągu (liczba).

Przykładowa funkcja: -

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

Uważam, że poniższe rozwiązanie będzie bardzo krótkie, bardzo szybkie, zdolne do pracy z bardzo długimi ciągami, zdolne do obsługi wyszukiwania wielu znaków, odporne na błędy i zdolne do obsługi wyszukiwania pustych ciągów.

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

Przykładowe użycie:

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

Powyższy kod naprawia główny błąd wydajności w Jakubie Wawszczyku, że kod szuka dopasowania nawet po tym, jak indexOf mówi, że nie ma, a jego wersja nie działa, ponieważ zapomniał podać parametry wejściowe funkcji.

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

W javascript możesz użyć powyższego kodu, aby uzyskać wystąpienie znaku w ciągu.

Moje rozwiązanie z ramda js:

const testString = 'somestringtotest'

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

countLetters(testString)

Link do REPL.

Funkcja przyjmuje ciąg znaków jako parametr i liczy wystąpienie każdego unikalnego znaku w ciągu. Wynik występuje w parze klucz-wartość dla każdego znaku.

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;

}