ฉันต้องนับจำนวนครั้งของอักขระในสตริง

ตัวอย่างเช่นสมมติว่าสตริงของฉันมี:

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

ฉันต้องการหาจำนวน,ตัวอักษรคอมม่าซึ่งก็คือ 3 และจำนวนของสตริงแต่ละตัวหลังจากแยกตามคอมม่าซึ่งก็คือ 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

jsfiddle

ใช้นิพจน์ทั่วไปตามตัวอักษรหากคุณรู้ว่าคุณกำลังค้นหาอะไรอยู่ก่อนหน้าหากไม่สามารถใช้ตัวRegExpสร้างและส่งผ่านgค่าสถานะเป็นอาร์กิวเมนต์

matchส่งคืนnullโดยไม่มีผลลัพธ์ดังนั้น|| []

คำตอบเดิมที่ฉันทำในปี 2009 อยู่ด้านล่าง มันสร้างอาร์เรย์ที่ไม่จำเป็น แต่การใช้ตัวแยกนั้นเร็วกว่า (ณ เดือนกันยายน 2014) ฉันสงสัยว่าถ้าฉันต้องการความเร็วจริงๆคงไม่มีคำถามที่ฉันจะใช้การแบ่ง แต่ฉันต้องการใช้การจับคู่

คำตอบเก่า (จาก 2009):

หากคุณกำลังมองหาจุลภาค:

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

หากคุณกำลังมองหาสาย

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

ทั้งคำตอบใน @ Lo และในการแยกการทดสอบ jsperf ที่โง่เง่าของฉันมาพร้อมความเร็วอย่างน้อยใน Chrome แต่การสร้างอาร์เรย์เพิ่มเติมอีกครั้งดูเหมือนจะไม่ได้มีเหตุผล

มีอย่างน้อยสี่วิธี ตัวเลือกที่ดีที่สุดซึ่งควรจะเป็นเครื่องมือที่พัฒนาเร็วที่สุดสำหรับ RegEx ดั้งเดิม - วางไว้ที่ด้านบน jsperf.com ไม่สามารถใช้งานได้มิฉะนั้นฉันจะให้สถิติประสิทธิภาพแก่คุณ

อัปเดต : โปรดค้นหาการทดสอบประสิทธิภาพที่นี่และดำเนินการด้วยตนเองเพื่อสนับสนุนผลการปฏิบัติงานของคุณ ข้อมูลเฉพาะของผลลัพธ์จะได้รับในภายหลัง

1

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

2

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

ไม่แนะนำให้แยก ทรัพยากรหิว จัดสรรอินสแตนซ์ใหม่ของ 'Array' สำหรับการแข่งขันแต่ละครั้ง อย่าลองใช้ไฟล์> 100MB ผ่าน FileReader คุณสามารถสังเกตการใช้งาน EXACT ได้อย่างง่ายดายโดยใช้ตัวเลือกProfiler ของ 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

ค้นหาอักขระเดี่ยว

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

ปรับปรุง:

5

การแมปองค์ประกอบและการกรองไม่แนะนำเนื่องจากการจัดสรรทรัพยากรโดยรวมแทนที่จะใช้ Pythonian 'generators'

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

แชร์: ฉันทำแก่นสารนี้ด้วย 8 วิธีการนับตัวละครในปัจจุบันดังนั้นเราจึงสามารถรวมกลุ่มและแบ่งปันความคิดของเราได้โดยตรงเพื่อความสนุกและอาจเป็นมาตรฐานที่น่าสนใจ :)

https://gist.github.com/2757250

เพิ่มฟังก์ชั่นนี้ใน 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;
};

การใช้งาน:

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

การค้นหาโดย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

เพียงใช้การแบ่งเพื่อค้นหาจำนวนที่เกิดขึ้นของตัวละครในสตริง

mainStr.split(',').length // ให้ 4 ซึ่งเป็นจำนวนสตริงหลังจากแยกโดยใช้ตัวคั่นจุลภาค

mainStr.split(',').length - 1 // ให้ 3 ซึ่งเป็นจำนวนเครื่องหมายจุลภาค

นี่คือโซลูชันที่คล้ายกัน แต่ใช้ Array.prototype.reduce

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

ดังที่ได้กล่าวไปแล้วString.prototype.splitทำงานได้เร็วกว่าString.prototype.replaceมาก

ฉันพบว่าวิธีที่ดีที่สุดในการค้นหาอักขระในสตริงที่มีขนาดใหญ่มาก (นั่นคือ 1,000,000 ตัวอักษรเป็นต้น) คือการใช้replace()วิธีนี้

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

คุณสามารถเห็นชุดJSPerf อีกชุดเพื่อทดสอบวิธีนี้พร้อมกับวิธีอื่นในการค้นหาอักขระในสตริง

นอกจากนี้คุณยังสามารถพักสายของคุณและทำงานกับมันเหมือนอาร์เรย์ขององค์ประกอบที่ใช้

• Array.prototype.filter ()

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

console.log(commas);

หรือ

• Array.prototype.reduce ()

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

console.log(commas);

ฉันทำการปรับปรุงเล็กน้อยในคำตอบที่ยอมรับจะช่วยให้ตรวจสอบกับการจับคู่ case-sensitive / case-insensitive และเป็นวิธีการที่แนบมากับวัตถุสตริง:

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 คือ case-insensitivity, default เป็น false จะอนุญาตให้มีตัวเลือกสำหรับการจับคู่แบบ insensitive

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

amount_of_os2จะเท่ากับ

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

เวลานี้amount_of_osจะเท่ากับ3เนื่องจากได้รับทุนOจากสตริงที่รวมอยู่ในการค้นหา

ตกลงคนอื่น ๆ ที่มี regexp - อาจจะไม่เร็ว แต่สั้นและดีกว่าที่อ่านได้แล้วคนอื่น ๆ ในกรณีของฉันเพียง'_'เพื่อนับ

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

เพียงแค่ลบทุกอย่างที่ไม่เหมือนกับตัวละครของคุณ แต่มันดูไม่ดีกับสตริงที่เป็นอินพุต

ประสิทธิภาพการทำงานของ 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");

วิธีที่ง่ายที่สุดที่ฉันค้นพบ ...

ตัวอย่าง-

str = 'mississippi';

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

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

ฉันกำลังทำงานในโครงการขนาดเล็กที่ต้องการตัวนับสตริงย่อย การค้นหาวลีที่ไม่ถูกต้องทำให้ฉันไม่มีผลลัพธ์ แต่หลังจากเขียนการใช้งานของฉันเองฉันก็สะดุดกับคำถามนี้ อย่างไรก็ตามนี่คือวิธีของฉันมันอาจช้ากว่าที่นี่มาก แต่อาจเป็นประโยชน์กับใครบางคน:

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

หากคุณใช้lodashวิธี_.countByจะทำสิ่งนี้:

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

วิธีนี้ใช้ได้กับอาเรย์ด้วย:

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

นี่คือทางออกของฉัน มีวิธีแก้ไขปัญหามากมายที่โพสต์ก่อนหน้าฉัน แต่ฉันชอบที่จะแบ่งปันมุมมองของฉันที่นี่

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

ที่นี่คุณพบ REPL ของฉัน

วิธีที่เร็วที่สุดดูเหมือนว่าจะผ่านตัวดำเนินการดัชนี:

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

ต่อไปนี้ใช้นิพจน์ทั่วไปเพื่อทดสอบความยาว testex ทำให้คุณมั่นใจได้ว่าคุณไม่มีตัวอักษรที่ไม่ใช่เครื่องหมายจุลภาคติดต่อกัน 16 ตัวขึ้นไป หากผ่านการทดสอบก็จะดำเนินการแยกสตริง การนับจุลภาคนั้นง่ายพอ ๆ กับการนับโทเค็นลบหนึ่ง

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

สิ่งที่เกี่ยวกับ string.split (ต้องการCharecter) .length-1

ตัวอย่าง:

var str = "hellow ชีวิตเป็นอย่างไร"; var len = str.split ("h"). length-1; จะให้จำนวน 2 สำหรับอักขระ "h" ในสตริงด้านบน

ฉันใช้ Node.js v.6.0.0 และเร็วที่สุดคืออันที่มีดัชนี (วิธีที่ 3 ในคำตอบของ Lo Sauer)

ประการที่สองคือ:

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

นี่เป็นวิธีหนึ่งที่เกือบเร็วพอ ๆ กับการแยกและวิธีการแทนที่ซึ่งเร็วกว่าวิธี regex เล็กน้อย (เป็นโครเมียม)

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

ฉันเพิ่งทำการทดสอบที่รวดเร็วและสกปรกบนrepl.itโดยใช้ Node v7.4 สำหรับอักขระตัวเดียวมาตรฐานสำหรับการวนซ้ำนั้นเร็วที่สุด:

บางรหัส :

// 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.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

และมี:

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

ทำงานร่วมกับจำนวนเต็มเกินไป!

ทางออกของฉัน:

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

วิธีที่ห้าใน Leo Sauers ตอบล้มเหลวถ้าตัวละครอยู่ที่จุดเริ่มต้นของสตริง เช่น

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

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

จะให้ 2 แทน 3 เพราะ funtion ตัวกรอง Boolean ให้ค่าเท็จเป็น 0

ฟังก์ชั่นตัวกรองอื่น ๆ ที่เป็นไปได้:

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

ฉันรู้ว่านี่อาจเป็นคำถามเก่า แต่ฉันมีทางออกที่ง่ายสำหรับผู้เริ่มต้นระดับต่ำใน JavaScript

เป็นผู้เริ่มต้นผมเท่านั้นที่จะเข้าใจบางส่วนของการแก้ปัญหากับคำถามนี้ดังนั้นผมจึงใช้สองซ้อนกันสำหรับลูปเพื่อตรวจสอบตัวละครแต่ละตัวกับทุกตัวละครอื่น ๆ ในสตริง, incrementing นับตัวแปรสำหรับตัวละครแต่ละตัวพบว่ามีค่าเท่ากับตัวละครที่

ฉันสร้างวัตถุว่างใหม่โดยที่คีย์คุณสมบัติแต่ละตัวเป็นอักขระและค่าเป็นจำนวนครั้งที่อักขระแต่ละตัวปรากฏในสตริง (นับ)

ฟังก์ชั่นตัวอย่าง: -

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 จะบอกว่าไม่มีและรุ่นของตัวเองไม่ทำงานเพราะเขาลืมที่จะให้พารามิเตอร์อินพุตฟังก์ชั่น

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

ในจาวาสคริปต์คุณสามารถใช้โค้ดด้านบนเพื่อรับตัวอักษรในสตริง

โซลูชันของฉันกับ ramda js:

const testString = 'somestringtotest'

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

countLetters(testString)

ลิงก์ไปที่ REPL

ฟังก์ชั่นใช้สตริง str เป็นพารามิเตอร์และนับจำนวนอักขระที่ไม่ซ้ำกันในสตริง ผลลัพธ์มาในคู่ของคีย์ - ค่าสำหรับแต่ละอักขระ

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;

}