我更新了这一答案。 我赞成更好地使用对应办法的想法,但进展缓慢:

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上作为论据通过,则使用固定字句。

, 并随附结果, no>>>>>。

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

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

function countChar(char: string, string: string): number  {

  return string.split(char).length - 1

}

countChar( x ,  foo x bar x baz x )

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

www.un.org/Depts/DGACM/index_spanish.htm 采用职位索引

与使用<代码>slice的第一种方法类似,但我们在检索该方法时,将利用<条码>的参数,即。

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

从个人角度讲,我首先采取第二种做法,但两者在处理大街时都是罚款和效劳的,但规模也较小。

我对已接受的答复稍加改进,因此可以检查对案件敏感/对案件敏感的对等,并且是一种与扼杀目标相关的方法:

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

lit is the string to search for ( such as ex ), and cis is case-insensitivity, defaulted to false, it will allow for choice of case insensitive matches.

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

amount_of_os would be equal to 2.

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

时间:amount_of_os 等于3,因为从星号中提取的资本代码已纳入搜索。

1. 最容易发现......

例

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

页: 1

我刚刚在

www.un.org/Depts/DGACM/index_spanish.htm 一些代码:

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

<>Restrong>Update 20-Oct-24: 还是Node.js 12一案(此处与它一起讨论)。

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

我正致力于一个小型项目,需要一个分级的反响。 寻找错误的短语给我没有结果,不过,在撰写我自己的执行情况之后,我对这个问题 st。 不管怎么说,这是我的方法,它可能比这里大多数人要慢,但可能对某人有帮助:

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

Interesting read discussing the above: http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

说明。

例:

var str = "hellow how is life"; var len = str.split("h").length-1; will give count 2 for character "h" in the above string;

www.un.org/Depts/DGACM/index_spanish.htm 最快的方法似乎是通过指数操作者:。

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

www.un.org/spanish/ecosoc 或作为原型的功能:

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

这是一个非常短的职能。

String.prototype.reduce = Array.prototype.reduce;

String.prototype.count = function(c) {
    return this.reduce(((n, x) => n + (x === c ? 1 : 0)), 0)
};

const n = "bugs bunny was here".count("b")
console.log(n)

与上述原型类似,但不为扼杀分配阵列。 分配是上文几乎每个版本的问题,但备选案文除外。 这避免了假装法,重新使用已安装的浏览器。 减少职能。

下面用定期的表述来测试时间长度。 测试确保你不会有16个或16个以上的连续非商品特性。 如果它通过测试,那么它就开始分割扼杀。 计算mas数与点数减去点数一样简单。

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的Im,最快的是指数(Lo Sauer的回答第3种方法)。

第二是:

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()和替代方法一样快,这些方法比reg法( 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;
  }
}

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

加入一个阵列,使我们有一些因素,其数量总是比性质上的事例多1个。 这可能不是最富有记忆力的,但如果你的投入总是很小,那就是一个直截了当和容易理解的方式。

如果你需要穿透非常大的体(超过100个特性),或者如果是处理大量数据的核心结构,我会建议采取不同的战略。

我的解决办法:

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

我知道这个问题可能是一个老问题,但我对贾瓦文的低层开端人有一个简单的解决办法。

作为开端人,我只能理解这个问题的一些解决办法,因此,我使用了两个封顶的<>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;
}