Javascript에서 문자열에 포함된 문자의 발생 횟수를 카운트합니다.

Javascript에서 문자열에 포함된 문자의 발생 횟수를 카운트합니다.

문자열에 포함된 문자의 발생 횟수를 셀 필요가 있습니다.

예를 들어 문자열에 다음이 포함되어 있다고 가정합니다.

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

를 ,입입, 입입입니다.쉼표를 따라 분할된 후 개별 문자열의 개수(4)입니다.

또한 str1 또는 str2 또는 str3 또는 str4의 각 문자열이 예를 들어 15자를 넘지 않아야 합니다.

저는 이 답변을 업데이트했습니다.성냥을 사용하는 것이 좋지만 더 느립니다.

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

미리 에는 정규 하고, 그렇지 않은 표현 할 수 있습니다.그렇지 않은 경우 정규 표현 리터럴을 사용할 수 있습니다.RegExp및 인.g이치노

matchnull, 「결과는 없습니다」라고 하는 일 없이, 라고 하는 것입니다.|| []

2009년에 제가 한 답변은 다음과 같습니다.어레이를 불필요하게 생성하지만 분할을 사용하는 것이 더 빠릅니다(2014년 9월 기준).저는 양면성이기 때문에 속도가 정말 필요하다면 스플릿을 사용하는 것은 당연하지만 성냥을 사용하고 싶습니다.

오래된 답변(2009년부터):

콤마를 찾고 있는 경우:

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

스트릭을 찾는다면

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

@Lo의 답변과 저 자신의 어리석은 성능 테스트 스플릿 모두 적어도 Chrome에서는 속도가 앞서지만, 추가 어레이를 만드는 것은 적절하지 않은 것 같습니다.

적어도 다섯 가지 방법이 있다.가장 빠른 옵션(원어민 RegEx 엔진)이 상단에 배치됩니다.

방법 1

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

방법 2

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

스플릿은 리소스가 부족하기 때문에 권장되지 않습니다.각 일치에 대해 'Array'의 새 인스턴스를 할당합니다.FileReader를 통해 100MB 이상의 파일을 시도하지 마십시오.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) );
// returns 2

방법 4

단일 문자 검색

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

방법 5

요소 매핑 및 필터링.이는 피토니아 '제너레이터'를 사용하는 것보다 전체적인 자원 사전 할당 때문에 권장되지 않습니다.

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

Share: 저는 현재 8가지 문자 계산 방법을 사용하여 이 요지를 만들었습니다.그래서 우리는 아이디어를 직접 공유하고 공유할 수 있습니다.단, 재미로, 그리고 아마 몇 가지 흥미로운 벤치마크를 위해서일 것입니다.

이 기능을 스팅 프로토타입에 추가합니다.

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

사용방법:

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

단순히 분할을 사용하여 문자열 내의 문자의 발생 횟수를 확인합니다.

mainStr.split(',').length // 구분 기호 쉼표를 사용하여 분할한 문자열 수인 4를 제공합니다.

mainStr.split(',').length - 1 // 콤마 카운트인 3을 제공합니다.

빠른 Google 검색에서 이 정보를 얻을 수 있습니다(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;
}

다음과 같이 사용합니다.

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

스트링을 쉬게 하고 여러 요소의 배열처럼 작업할 수도 있습니다.

• Array.protype.필터()

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

console.log(commas);

또는

• Array.protype.reduce()

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

console.log(commas);

해결책이 , 이은 이렇게 쓰이고 있어요.Array.prototype.reduce

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

바와 같이, 씀씀듯 as as 。String.prototype.split 훨씬 작동 속도가 String.prototype.replace.

lodash를 사용하는 경우 _.countBy 메서드는 다음을 수행합니다.

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

이 방법은 어레이에서도 사용할 수 있습니다.

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

있는 -, 읽기 보다 - regexp가 더 낫습니다. - case - 른른 른른 른른 른른 른른 른른 른른 른른 른 ok 른 른 른 ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok ok'_'

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

문자처럼 보이지 않는 것은 모두 삭제해 주세요만, 문자열을 입력으로 하면 보기 좋지 않습니다.

13년 동안 이 답이 나오지 않았다니 놀랍다.직감적으로 보면 가장 빠른 속도라고 할 수 있습니다.

const s = "The quick brown fox jumps over the lazy dog.";
const oCount = s.length - s.replaceAll('o', '').length;

문자열에 2종류의 문자만 있는 경우, 이것이 보다 고속입니다.

const s = "001101001";
const oneCount = s.replaceAll('0', '').length;

큰 를 들어 1,하는 가장 은 "1,000자"를 입니다.replace()★★★★★★ 。

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

이 메서드를 테스트하기 위한 다른 JSPerf 스위트를 문자열 내의 문자를 검색하는 다른 메서드와 함께 표시할 수 있습니다.

스플릿과 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");

수용된 답변을 약간 개선했습니다.대소문자를 구분하거나 대소문자를 구분하지 않는 매칭으로 확인할 수 있으며 문자열 객체에 첨부되어 있는 메서드입니다.

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

lit는 검색하는 문자열('ex' 등), cis는 대소문자를 구분하며 기본값은 false로 대소문자를 구분하지 않는 일치를 선택할 수 있습니다.

---

To search the string 'I love StackOverflow.com' for the lower-case letter 'o', you would use:

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

amount_of_os 되다2

---

If we were to search the same string again using case-insensitive matching, you would use:

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

★★★★★★★★★★★★★★★★.amount_of_os 되다3O이치노

가장 쉬운 방법은...

예-

str = 'mississippi';

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

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

제 해결책은 이렇습니다.제 앞에 이미 많은 해결책이 게시되어 있습니다.하지만 나는 여기서 내 견해를 공유하는 것을 좋아한다.

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

여기서 내 리플리케이션을 찾을 수 있습니다.

Node v7.4를 사용하여 repl.it에서 매우 빠르고 더러운 테스트를 수행했습니다.단일 문자의 경우 루프의 표준이 가장 빠릅니다.

일부 코드:

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

몇 번의 실행 결과:

perfIt()
charCount1: 3.301ms
charCount2: 11.652ms
charCount3: 174.043ms
undefined

perfIt()
charCount1: 2.110ms
charCount2: 11.931ms
charCount3: 177.743ms
undefined

perfIt()
charCount1: 2.074ms
charCount2: 11.738ms
charCount3: 152.611ms
undefined

perfIt()
charCount1: 2.076ms
charCount2: 11.685ms
charCount3: 154.757ms
undefined

업데이트 2021-2월 10일: repl.it 데모에서 오타 수정

업데이트 2020-10월 24일: Node.js 12도 마찬가지입니다(여기서 직접 플레이)

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

서브스트링 카운터가 필요한 작은 프로젝트를 진행하고 있었습니다.잘못된 문구를 검색해도 아무 결과도 얻을 수 없었습니다만, 자신의 실장을 쓰고 나서 우연히 이 질문을 하게 되었습니다.어쨌든, 제 방법은 여기 있는 대부분의 경우보다 느리지만 누군가에게 도움이 될 수 있습니다.

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/

이 구현에 실패하거나 일부 표준을 따르지 않을 경우 알려주시기 바랍니다. :)

업데이트 대체 방법:

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

포함:

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

위의 내용에 대한 흥미로운 기사:http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

string.split(desiredCharecter)은 어떨까요?길이-1

예:

var str = "hellow how is life", var len = str.hellowh", length-1. 위 문자열의 문자 "h"에 대한 카운트 2를 제공합니다.

가장 빠른 방법은 인덱스 연산자를 사용하는 것 같습니다.

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

또는 프로토타입 기능으로:

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

function len(text,char){

return text.innerText.split(string).length
}

console.log(len("str1,str2,str3,str4",","))

이것은 매우 짧은 함수입니다.

나는 내가 여기 파티에 늦었다는 것을 알지만 아무도 가장 기본적인 접근법으로 이것에 대답하지 않았다는 것이 다소 당황스러웠다.이 질문에 대해 커뮤니티에서 제공하는 답변의 대부분은 반복 기반이지만 모두 문자 단위로 문자열로 이동하기 때문에 효율적이지 않습니다.

각 문자 위를 이동하는 수천 개의 문자를 포함하는 큰 문자열을 취급할 경우 코드 냄새는 말할 것도 없고 발생 개수도 알 수 없습니다.은 다다음음 of of of the the the 를 활용합니다.slice,indexOf 신뢰할 수 있는 의 '전통적인'을 사용합니다.while루프. 이러한 접근 방식은 각 문자를 살펴볼 필요가 없으며 발생 횟수를 계산하는 데 걸리는 시간을 크게 단축할 수 있습니다.이것들은 줄타기를 필요로 하는 파서나 어휘 분석기에서 볼 수 있는 것과 비슷한 논리를 따릅니다.

슬라이스와 함께 사용

에서는, 「」를 활용하고 .slice 모든 ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★.indexOf성냥 끈을 통해 이전 검색된 물약을 제거할 것입니다. 할 때마다indexOf이치노

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

위치에서 IndexOf와 함께 사용

.slice, 에, 「검색중의 문자열」을 합니다.from의 파라미터indexOf★★★★★★ 。

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

개인적으로는 첫 번째 방법보다 두 번째 방법을 택하지만 큰 현을 다룰 때는 두 가지 모두 훌륭하고 성능도 뛰어납니다.

다음은 정규식을 사용하여 길이를 테스트합니다.testex는 연속된 16자 이상의 콤마가 없음을 보증합니다.테스트를 통과하면 문자열을 분할합니다.콤마 카운트는 토큰에서1을 빼면 됩니다.

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

저는 Node.js v.6.0.0을 사용하고 있으며 가장 빠른 것은 인덱스가 있는 것입니다(Lo Sauer의 답변 중 세 번째 방법).

두 번째는 다음과 같습니다.

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

또, 다음과 같은 것이 있습니다.

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

정수에도 대응합니다!

마찬가지로 것이 있습니다.split()메서드(및 메서드.regex 메서드.

let num = 0;
let str = "str1,str2,str3,str4";
//Note: Pre-calculating `.length` is an optimization;
//otherwise, it recalculates it every loop iteration.
let len = str.length;
//Note: Don't use a `for (... of ...)` loop, it's slow!
for (let charIndex = 0; charIndex < len; ++charIndex) {
  if (str[charIndex] === ',') {
    ++num;
  }
}

var mainStr = "str1,str2,str3,str4";
var splitStr = mainStr.split(",").length - 1; // subtracting 1 is important!
alert(splitStr);

배열로 분할하면 여러 요소가 제공되며, 이는 항상 문자의 인스턴스 수보다 1개 더 많습니다.이 방법은 메모리 효율이 가장 높지 않을 수 있지만 입력이 항상 작을 경우 이 방법은 간단하고 이해하기 쉬운 방법입니다.

매우 큰 문자열(수백자 이상)을 해석해야 하는 경우나 대량의 데이터를 처리하는 코어 루프에 있는 경우에는 다른 전략을 권장합니다.

솔루션:

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

오래된 질문인 것은 알지만, JavaScript의 저레벨 초보자를 위한 간단한 솔루션이 있습니다.

초보자로서 이 질문에 대한 해답은 몇 가지밖에 이해하지 못했기 때문에 두 개의 중첩된 FOR 루프를 사용하여 문자열 내의 다른 모든 문자와 대조하여 각 문자와 동일한 문자의 카운트 변수를 늘렸습니다.

각 속성 키가 문자이고 값이 문자열(카운트)에 나타나는 각 문자의 횟수인 빈 객체를 새로 만들었습니다.

함수 예:-

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

아래 솔루션은 매우 짧고 매우 빠르고 긴 문자열로 작업할 수 있으며 여러 문자 검색, 오류 방지 및 빈 문자열 검색을 지원할 수 있습니다.

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

사용 예:

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

위의 코드는 Jakub Wawszczyk의 주요 퍼포먼스 버그를 수정하고 있습니다.이 버그는 indexOf가 함수의 입력 파라미터를 입력하지 않았기 때문에 indexOf가 존재하지 않으며 버전 자체가 동작하지 않습니다.

언급URL : https://stackoverflow.com/questions/881085/count-the-number-of-occurrences-of-a-character-in-a-string-in-javascript