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

更新:这可能是简单的，但它不是最快的。参见下面的基准测试。

令人惊讶的是，13年了，这个答案还没有出现。从直觉上看，它应该是最快的:

const s = "The quick brown fox jumps over the lazy dog.";
const oCount = s.length - s.replaceAll('o', '').length;

如果字符串中只有两种字符，那么这样仍然更快:

const s = "001101001";
const oneCount = s.replaceAll('0', '').length;

基准

const { performance } = require('node:perf_hooks');

const ITERATIONS = 10000000;
const TEST_STRING = "The quick brown fox jumps over the lazy dog.";

console.log(ITERATIONS, "iterations");

let sum = 0; // make sure compiler doesn't optimize code out
let start = performance.now();
for (let i = 0; i < ITERATIONS; ++i) {
  sum += TEST_STRING.length - TEST_STRING.replaceAll('o', '').length;
}
let end = performance.now();
console.log("  replaceAll duration", end - start, `(sum ${sum})`);

sum = 0;
start = performance.now();
for (let i = 0; i < ITERATIONS; ++i) {
  sum += TEST_STRING.split('o').length - 1
}
end = performance.now();
console.log("  split duration", end - start, `(sum ${sum})`);

10000 iterations
  replaceAll duration 2.6167500019073486 (sum 40000)
  split duration 2.0777920186519623 (sum 40000)
100000 iterations
  replaceAll duration 17.563208997249603 (sum 400000)
  split duration 8.087624996900558 (sum 400000)
1000000 iterations
  replaceAll duration 128.71587499976158 (sum 4000000)
  split duration 64.15841698646545 (sum 4000000)
10000000 iterations
  replaceAll duration 1223.3415840268135 (sum 40000000)
  split duration 629.1629169881344 (sum 40000000)

我更新了这个答案。我更喜欢使用火柴的想法，但它更慢:

console.log（（“str1，str2，str3，str4”.match（/，/g） ||[]）.长度）;日志 3 console.log（（“str1，str2，str3，str4”.match（new RegExp（“str”， “g”）） ||[]）.长度）;日志 4

如果事先知道要搜索什么，可以使用正则表达式文字;如果不知道，可以使用RegExp构造函数，并传入g标志作为参数。

匹配结果为空，因此|| []

以下是我在2009年给出的原始答案。它创建了一个不必要的数组，但是使用分割更快(截至2014年9月)。我很矛盾，如果我真的需要速度，毫无疑问我会使用分拆，但我更喜欢使用匹配。

旧答案(2009年):

如果你在找逗号:

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

如果你在找str

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

在@Lo的回答和我自己的愚蠢的性能测试中，分裂在速度上领先，至少在Chrome中，但再次创建额外的数组似乎不理智。

下面是一个类似的解决方案，但它使用了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快得多。

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

我知道这可能是一个老问题，但我有一个简单的解决方案为低水平的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;
}