Tôi cần đếm số lần xuất hiện của một ký tự trong một chuỗi.

Ví dụ: giả sử chuỗi của tôi chứa:

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

Tôi muốn tìm số đếm dấu phẩy ,, là 3. Và số chuỗi riêng lẻ sau khi phân tách dọc theo dấu phẩy, là 4.

Tôi cũng cần xác thực rằng mỗi chuỗi, ví dụ str1 hoặc str2 hoặc str3 hoặc str4 không được vượt quá, giả sử, 15 ký tự.

Tôi đã cập nhật câu trả lời này. Tôi thích ý tưởng sử dụng một trận đấu tốt hơn, nhưng nó chậm hơn:

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

Sử dụng một biểu thức chính quy nếu bạn biết trước những gì bạn đang tìm kiếm, nếu không bạn có thể sử dụng hàm RegExptạo và truyền vào gcờ làm đối số.

matchtrả về nullmà không có kết quả|| []

Câu trả lời ban đầu tôi thực hiện năm 2009 là dưới đây. Nó tạo ra một mảng không cần thiết, nhưng sử dụng phân tách sẽ nhanh hơn (kể từ tháng 9 năm 2014). Tôi không rõ ràng, nếu tôi thực sự cần tốc độ, sẽ không có câu hỏi rằng tôi sẽ sử dụng tách, nhưng tôi thích sử dụng kết hợp hơn.

Câu trả lời cũ (từ năm 2009):

Nếu bạn đang tìm kiếm dấu phẩy:

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

Nếu bạn đang tìm kiếm str

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

Cả trong câu trả lời của @ Lo và trong bài kiểm tra jsperf ngớ ngẩn của riêng tôi đều đi trước về tốc độ, ít nhất là trong Chrome, nhưng một lần nữa tạo ra mảng bổ sung lại dường như không lành mạnh.

Có ít nhất bốn cách. Tùy chọn tốt nhất, cũng phải là công cụ RegEx gốc - nhanh nhất - được đặt ở trên cùng. jsperf.com hiện đang ngừng hoạt động, nếu không tôi sẽ cung cấp cho bạn số liệu thống kê hiệu suất.

Cập nhật : Xin vui lòng, tìm các bài kiểm tra hiệu suất ở đây và tự chạy chúng, để đóng góp kết quả hiệu suất của bạn. Các chi tiết cụ thể của kết quả sẽ được cung cấp sau.

1.

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

2.

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

chia không khuyến khích. Tài nguyên đói. Phân bổ các phiên bản mới của 'Mảng' cho mỗi trận đấu. Đừng thử điều đó đối với tệp> 100MB qua FileReader. Bạn thực sự có thể dễ dàng quan sát việc sử dụng tài nguyên CHÍNH XÁC bằng tùy chọn trình lược tả của 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.

tìm kiếm một nhân vật

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

Cập nhật:

5.

ánh xạ phần tử và lọc, không được đề xuất do sự phân bổ tài nguyên tổng thể của nó thay vì sử dụng 'máy phát điện' của Pythonia

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

Chia sẻ: Tôi đã thực hiện ý chính này , với 8 phương pháp đếm nhân vật hiện tại, vì vậy chúng tôi có thể trực tiếp tổng hợp và chia sẻ ý tưởng của mình - chỉ để cho vui, và có lẽ một số điểm chuẩn thú vị :)

https://gist.github.com/2757250

Thêm chức năng này vào nguyên mẫu sting:

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

sử dụng:

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

Một tìm kiếm nhanh của Google đã nhận được điều này (từ http://www.codecodex.com/wiki/index.php?title=Count_the_number_of_occurrences_of_a_specific_character_in_a_opes#JavaScript )

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

Sử dụng nó như thế này:

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

Đơn giản, sử dụng phần tách để tìm ra số lần xuất hiện của một ký tự trong chuỗi.

mainStr.split(',').length // cho 4 là số chuỗi sau khi phân tách bằng dấu phân cách dấu phẩy

mainStr.split(',').length - 1 // cho 3 là số dấu phẩy

Đây là một giải pháp tương tự, nhưng nó sử dụng Array.prototype.reduce

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

Như đã đề cập, String.prototype.splithoạt động nhanh hơn nhiều String.prototype.replace.

Tôi đã thấy rằng cách tiếp cận tốt nhất để tìm kiếm một ký tự trong một chuỗi rất lớn (chẳng hạn như dài 1 000 000 ký tự) là sử dụng replace()phương thức này.

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

Bạn có thể thấy một bộ JSPerf khác để kiểm tra phương thức này cùng với các phương thức tìm ký tự khác trong chuỗi.

Bạn cũng có thể nghỉ chuỗi của bạn và làm việc với nó như một mảng các phần tử bằng cách sử dụng

• Array.prototype.filter ()

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

console.log(commas);

Hoặc là

• Array.prototype.reduce ()

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

console.log(commas);

Tôi đã thực hiện một cải tiến nhỏ về câu trả lời được chấp nhận, nó cho phép kiểm tra với kết hợp phân biệt chữ hoa / chữ thường và phân biệt chữ hoa chữ thường và là một phương thức được gắn vào đối tượng chuỗi:

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

lit là chuỗi để tìm kiếm (chẳng hạn như 'ex') và cis không phân biệt chữ hoa chữ thường, được mặc định là false, nó sẽ cho phép lựa chọn các trường hợp khớp không phân biệt chữ hoa chữ thường.

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

amount_of_ossẽ bằng với 2.

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

Lần này, amount_of_ossẽ bằng 3, vì vốn Otừ chuỗi được đưa vào tìm kiếm.

ok, một cái khác với regrec - có thể không nhanh, nhưng ngắn và dễ đọc hơn những người khác, trong trường hợp của tôi chỉ '_'để đếm

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

chỉ cần loại bỏ mọi thứ trông không giống char của bạn nhưng nó trông không đẹp bằng một chuỗi làm đầu vào

Hiệu suất của 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");

Cách dễ nhất tôi tìm ra ...

Thí dụ-

str = 'mississippi';

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

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

Tôi đang làm việc trên một dự án nhỏ yêu cầu bộ đếm chuỗi con. Tìm kiếm các cụm từ sai cung cấp cho tôi không có kết quả, tuy nhiên sau khi viết bài thực hiện của riêng tôi, tôi đã vấp phải câu hỏi này. Dù sao, đây là cách của tôi, nó có thể chậm hơn hầu hết ở đây nhưng có thể hữu ích cho ai đó:

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/

Xin vui lòng cho tôi biết nếu bạn thấy việc triển khai này thất bại hoặc không tuân theo một số tiêu chuẩn! :)

CẬP NHẬT Bạn có thể muốn thay thế:

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

Với:

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

Thú vị đọc thảo luận về những điều trên: http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

Nếu bạn đang sử dụng lodash, phương thức _.countBy sẽ làm điều này:

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

Phương pháp này cũng hoạt động với mảng:

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

Đây là giải pháp của tôi. Rất nhiều giải pháp đã được đăng trước tôi. Nhưng tôi thích chia sẻ quan điểm của tôi ở đây.

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

Ở đây bạn tìm thấy REPL của tôi

Phương pháp nhanh nhất dường như thông qua toán tử chỉ mục:

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

Hoặc là một chức năng nguyên mẫu:

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

Dưới đây sử dụng một biểu thức chính quy để kiểm tra độ dài. testex đảm bảo bạn không có 16 ký tự không dấu phẩy liên tiếp trở lên. Nếu nó vượt qua bài kiểm tra, thì nó sẽ tiến hành phân tách chuỗi. đếm dấu phẩy đơn giản như đếm số token trừ đi một.

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

Điều gì về chuỗi.split (wishCharecter) .length-1

Thí dụ:

var str = "hellow how is life"; var len = str.split ("h"). length-1; sẽ đưa ra số 2 cho ký tự "h" trong chuỗi trên;

Tôi đang sử dụng Node.js v.6.0.0 và nhanh nhất là phương pháp có chỉ mục (phương thức thứ 3 trong câu trả lời của Loerer).

Thứ hai là:

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

Đây là một phương pháp gần như nhanh bằng phương pháp phân tách và thay thế, nhanh hơn một chút so với phương thức regex (bằng chrome).

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

Tôi vừa thực hiện một thử nghiệm rất nhanh và bẩn trên repl.it bằng Node v7.4. Đối với một ký tự, tiêu chuẩn cho vòng lặp là nhanh nhất:

Một số mã :

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

Kết quả từ một vài lần chạy :

 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

Và có:

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

Hoạt động với số nguyên quá!

Giải pháp của tôi:

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

Phương thức thứ năm trong câu trả lời của Leo Sauers không thành công, nếu ký tự nằm ở đầu chuỗi. ví dụ

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

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

sẽ cho 2 thay vì 3, vì bộ lọc funtion Boolean cung cấp sai cho 0.

Chức năng lọc khác có thể:

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

Tôi biết đây có thể là một câu hỏi cũ nhưng tôi có một giải pháp đơn giản cho người mới bắt đầu trình độ thấp trong JavaScript.

Khi mới bắt đầu, tôi chỉ có thể hiểu một số giải pháp cho câu hỏi này nên tôi đã sử dụng hai vòng lặp FOR lồng nhau để kiểm tra từng ký tự đối với mỗi ký tự khác trong chuỗi, tăng một biến đếm cho mỗi ký tự được tìm thấy bằng với ký tự đó.

Tôi đã tạo một đối tượng trống mới trong đó mỗi khóa thuộc tính là một ký tự và giá trị là số lần mỗi ký tự xuất hiện trong chuỗi (đếm).

Hàm ví dụ: -

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

Tôi tin rằng bạn sẽ tìm thấy giải pháp dưới đây rất ngắn, rất nhanh, có thể làm việc với các chuỗi rất dài, có thể hỗ trợ nhiều tìm kiếm ký tự, bằng chứng lỗi và có thể xử lý các tìm kiếm chuỗi trống.

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

Ví dụ sử dụng:

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

Đoạn mã trên đã sửa lỗi hiệu năng chính trong Jakub Wawszchot rằng mã vẫn tiếp tục tìm kiếm sự trùng khớp ngay cả sau khi indexOf nói rằng không có gì và bản thân phiên bản của anh ta không hoạt động vì anh ta quên cung cấp các tham số đầu vào của hàm.

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

Trong javascript, bạn có thể sử dụng mã ở trên để có sự xuất hiện của một ký tự trong chuỗi.

Giải pháp của tôi với ramda js:

const testString = 'somestringtotest'

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

countLetters(testString)

Liên kết với REPL.

Hàm lấy chuỗi str làm tham số và đếm số lần xuất hiện của từng ký tự duy nhất trong chuỗi. Kết quả có trong cặp khóa - giá trị cho mỗi ký tự.

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;

}