计算Java字符串中字符出现的次数

2020/09/24 13:21 · javascript ·  · 0评论

我需要计算一个字符在一个字符串中出现的次数。

例如,假设我的字符串包含:

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年9月)。我很矛盾,如果我真的需要速度,那我会使用分割,这是毫无疑问的,但是我更喜欢使用match。

旧答案(从2009年开始):

如果要查找逗​​号:

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

如果您正在寻找str

(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

不建议拆分。资源匮乏。为每个匹配分配“数组”的新实例。不要通过FileReader对大于100MB的文件进行尝试。实际上,您可以使用Chrome的分析器选项轻松观察EXACT资源的使用情况

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的“生成器”,因此不建议使用

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原型:

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

我发现,搜索很大字符串(例如,长度为1000000个字符)中的字符的最佳方法是使用该replace()方法。

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

您可以看到另一个JSPerf套件来测试此方法以及其他在字符串中查找字符的方法。

您还可以休息字符串,并像使用元素数组一样使用它

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

我对可接受的答案进行了一些改进,它允许使用区分大小写/不区分大小写的匹配进行检查,并且是附加到字符串对象的一种方法:

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字符串中的大写字母已包含在搜索中。

OK,另一个中与正则表达式-可能不是很快,但短期和更好的可读性,其他人,在我的情况正好'_'来算

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

只需删除所有看起来不像char的东西,但在输入字符串的情况下看起来不太好

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

我发现的最简单方法是...

例-

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

我只是使用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.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

这是我的解决方案。许多解决方案已经发布在我面前。但我喜欢在这里分享我的观点。

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(desiredCharecter).length-1

例:

var str =“让生活变得更美好”; var len = str.split(“ h”)。length-1; 将为上述字符串中的字符“ h”给出计数2;

我正在使用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方法一样快的方法,它们比regex方法(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;
  }
}

我的解决方案:

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,因为过滤器功能布尔值将false表示为0。

其他可能的过滤功能:

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

我知道这可能是个老问题,但是我为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表示不存在任何错误且其版本本身不起作用,因为他忘记提供函数输入参数后,该代码仍会继续寻找匹配项。

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)

链接到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;

} 
本文地址:http://javascript.askforanswer.com/jisuanjavazifuchuanzhongzifuchuxiandecishu.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!