我需要统计一个字符在字符串中出现的次数。
例如，假设我的字符串包含：
var mainStr = "str1,str2,str3,str4";
我想找到逗号,字符的数量，即3。以及沿逗号拆分后的单个字符串的数量，即4。
我还需要验证每个字符串，即 str1 或 str2 或 str3 或 str4 不应超过 15 个字符。
【问题讨论】：
标签： javascript string
我已经更新了这个答案。我更喜欢使用匹配的想法，但速度较慢：
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 标志作为参数传入。
match 返回null 没有结果，因此|| []
我在 2009 年做出的原始答案如下。它不必要地创建了一个数组，但使用拆分更快（截至 2014 年 9 月）。我很矛盾，如果我真的需要速度，毫无疑问我会使用拆分，但我更喜欢使用匹配。
旧答案（从 2009 年开始）：
如果您正在寻找逗号：
(mainStr.split(",").length - 1) //3
如果您正在寻找 str
(mainStr.split("str").length - 1) //4
@Lo 的回答和我自己的愚蠢 performance test split 都在速度上领先，至少在 Chrome 中是这样，但再次创建额外的数组似乎并不明智。
【讨论】：
至少有五种方法。最好的选项，也应该是最快的（由于本机 RegEx 引擎）放在顶部。
("this is foo bar".match(/o/g)||[]).length;
// returns 2
"this is foo bar".split("o").length - 1;
// returns 2
不推荐拆分，因为它需要大量资源。它为每个匹配分配新的 'Array' 实例。不要尝试通过 FileReader 获取 >100MB 的文件。您可以使用 Chrome 的分析器 选项观察确切的资源使用情况。
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
搜索单个字符
var stringsearch = "o"
,str = "this is foo bar";
for(var i=count=0; i<str.length; count+=+(stringsearch===str[i++]));
// returns 2
元素映射和过滤。不建议这样做，因为它的整体资源预分配而不是使用 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
// returns 2
分享： 我做了这个gist，目前有 8 种字符计数方法，所以我们可以直接汇集和分享我们的想法 - 只是为了好玩，也许还有一些有趣的基准:)
【讨论】：
||[] 在做什么，但这个答案很棒！对于其他摸不着头脑的人，如果没有找到匹配项，match() 将返回 null，如果 match() 返回 null，||[] 将返回长度为 0 的数组，这意味着 length() 将返回 0 而不是生成输入错误。
index = -2就足够了，但非常感谢@Augustus
简单地说，使用 split 找出一个字符在字符串中出现的次数。
mainStr.split(',').length // 给出 4 是使用分隔符逗号分割后的字符串数mainStr.split(',').length - 1 // 给出 3 是逗号的个数
【讨论】：
将此函数添加到 sting 原型中：
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
【讨论】：
"stringsstringstrings".count("str") 呢？
快速搜索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
【讨论】：
* char (SyntaxError: nothing to repeat) 上的错误
您也可以rest 您的字符串并像使用元素数组一样使用它
const mainStr = 'str1,str2,str3,str4';
const commas = [...mainStr].filter(l => l === ',').length;
console.log(commas);或者
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)
}
如前所述，String.prototype.split 的运行速度比 String.prototype.replace 快得多。
【讨论】：
好的，另一个带有正则表达式的 - 可能不快，但比其他的短且可读性更好，在我的情况下，只需 '_' 计数
key.replace(/[^_]/g,'').length
删除所有看起来不像你的字符的东西 但是使用字符串作为输入看起来不太好
【讨论】：
如果您使用的是 lodash，_.countBy 方法将执行此操作：
_.countBy("abcda")['a'] //2
此方法也适用于数组：
_.countBy(['ab', 'cd', 'ab'])['ab'] //2
【讨论】：
我发现在非常大的字符串（例如 1 000 000 个字符长）中搜索字符的最佳方法是使用 replace() 方法。
window.count_replace = function (str, schar) {
return str.length - str.replace(RegExp(schar), '').length;
};
您可以查看yet another JSPerf 套件来测试此方法以及其他在字符串中查找字符的方法。
【讨论】：
Split 与 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，它将允许选择不区分大小写的匹配项。
'I love StackOverflow.com' 中搜索小写字母 'o'，您可以使用：
var amount_of_os = 'I love StackOverflow.com'.count('o');
amount_of_os 将等于 2。
var amount_of_os = 'I love StackOverflow.com'.count('o', true);
这一次，amount_of_os 将等于 3，因为字符串中的大写 O 会包含在搜索中。
【讨论】：
我发现的最简单的方法...
例子-
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
【讨论】：
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;
}
}
如果您发现此实施失败或不遵循某些标准，请告诉我！ :)
更新 您可能需要替换：
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
【讨论】：
我刚刚使用 Node v7.4 对 repl.it 做了一个非常快速而肮脏的测试。对于单个字符，标准 for 循环是最快的：
一些代码：
// 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 日更新：Still the case with Node.js 12 (play with it yourself here)
【讨论】：
charCountN(s+i, c)。此外，您有一个错字：charCount3 被错误输入为 charCount2，因此结果相似。如果您尝试使用我的修改，您会发现 split 是赢家，而正则表达式匹配排在第二位。
string.split(desiredCharecter).length-1 怎么样
例子：
var str = "你好，生活怎么样"; var len = str.split("h").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【讨论】：
下面使用正则表达式来测试长度。 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.");
}
【讨论】：
我使用的是 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() 和 replace 方法一样快的方法，它们比正则表达式方法（在 Chrome 和 Firefox 中）快一点。
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;
}
}
【讨论】：
split().length - 1 方法慢了 10 倍！这让我很生气！
split() 是在较低级别实现的，而存储和访问字符串的字符是在高级JS 中。我想知道什么可能会阻止您的代码 JIT... 嗯...
for 循环。我会更新你的答案；使用常规的for 循环，它与split() 一样快。我相信原因和这里列出的一样：stackoverflow.com/a/43821929/1599699
var mainStr = "str1,str2,str3,str4";
var splitStr = mainStr.split(",").length - 1; // subtracting 1 is important!
alert(splitStr);拆分成一个数组会给我们一些元素，这些元素总是比字符实例的数量多 1。这可能不是最节省内存的方法，但如果您的输入总是很小，这是一种直接且易于理解的方法。
如果您需要解析非常大的字符串（超过几百个字符），或者如果这是在处理大量数据的核心循环中，我会推荐不同的策略。
【讨论】：
我知道我在这里聚会迟到了，但我很困惑没有人用最基本的方法回答这个问题。社区为这个问题提供的大部分答案都是基于迭代的，但所有答案都是基于每个字符移动字符串，这并不是很有效。
在处理包含数千个字符的大字符串时，遍历每个字符以获取出现次数可能变得相当无关紧要，更不用说代码异味了。以下解决方案利用了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 的第一种方法，但它不会增加我们正在搜索的字符串，而是利用indexOf 方法中的from 参数。
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
就我个人而言，我倾向于第二种方法而不是第一种方法，但在处理大字符串时两者都很好且性能良好，但也适用于较小的字符串。
【讨论】：
我的解决方案：
function countOcurrences(str, value){
var regExp = new RegExp(value, "gi");
return str.match(regExp) ? str.match(regExp).length : 0;
}
【讨论】：
String.prototype.match 返回 null 没有匹配。这意味着不引用具有length 属性的对象。换句话说：String.prototype.match.call('willnotwork', /yesitwill/) === null
我知道这可能是一个老问题，但我为 JavaScript 的低级初学者提供了一个简单的解决方案。
作为一个初学者，我只能理解这个问题的一些解决方案，所以我使用了两个嵌套的 FOR 循环来检查字符串中的每个字符与每个其他字符，增加一个 count 为每个找到的与该字符相等的字符提供变量。
我创建了一个新的空白对象，其中每个属性键都是一个字符，值是每个字符在字符串中出现的次数（计数）。
示例函数：-
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);
在 javascript 中，您可以使用上面的代码来获取字符串中某个字符的出现。
【讨论】：
我的 ramda js 解决方案：
const testString = 'somestringtotest'
const countLetters = R.compose(
R.map(R.length),
R.groupBy(R.identity),
R.split('')
)
countLetters(testString)
【讨论】：