JavaScript函数自动计算字符串中的连续字母

我正在尝试（未成功）编写JavaScript函数LetterCount来计算字符串中的连续字母（而不是总数）

理想情况下： 信笺计数（“eeeee-ooohooe”）=[[“e”，5]，“o”，3]，“h”，2]，“o”，3]，“e”，2]]

以下代码仅当我已经知道字符串中的连续字母是什么时，才尝试计算字符串中的连续字母数：

function LetterCount(str) {
for (var i=0; i<str.length;i++) {
    var arr1=[]; arr2=[]; arr3=[]; arr4=[]; arr5=[];
    var e=0; o=0; h=0; o2=0; e2=0;
    if(str[i]="e") {
        arr1 += "e";
        e++;
    }
    arr1.push(e);
    if(str[i]="o") {
        arr2 += "o";
        o++;
    }
    arr2.push(o);
    if(str[i]="h") {
        arr3 += "h";
        h++;
    }
    arr3.push(h);
    if(str[i]="o") {
        arr4 += "o";
        o2++;
    }
    arr4.push(o2);
    if(str[i]="e") {
        arr5 += "e";
        e2++;
    }
    arr5.push(e2);
}
return arr1.concat(arr2).concat(arr3).concat(arr4).concat(arr5);
}

---

非常感谢您的帮助

我会使用在字符上键入的映射来存储连续字符的计数，然后在最后构建输出结构。根据你的例子，我不确定我是否完全理解你所说的连续是什么意思，但是你可以相应地调整逻辑来识别一个连续的数字

function LetterCount(str) {
  var counts = {};
  for (var i = 0, prevChar = null; i < str.length; i++) {
    var char = str.charAt(i);
    if(counts.hasOwnProperty(char) && char === prevChar) {
      counts[char] = counts[char] + 1;  
    } else if (!counts.hasOwnProperty(char)) {
      counts[char] = 0;
    }
    prevChar = char;
  }
  var res = [];
  for (var char in counts) {
    if (counts.hasOwnProperty(char)) {
      res.push([char,counts[char]);
    }
  }
  return res;
}

函数字母计数（str）{
变量计数={}；
for（var i=0，prevChar=null；i

这是我的答案：

function LetterCount(str) {
    var current, i = 0, l = str.length;
    var outputArr = [];
    while(i<l) {
        current = str.charAt(i);
        if(!i++ || outputArr[outputArr.length-1][0] !== current)
            outputArr[outputArr.length] = [current, 1];
        else outputArr[outputArr.length-1][1]++;
        }
    return outputArr;
    }

实际上已将“

[“o”，3]

修改为

[“o”，4]

；）

//节点v0.10.31
//断言v1.3.0
var assert=require（'assert'）；
函数字母计数（str）{
var i=0，
seq=0，
结果=[]；
而（i

您可以使用正则表达式匹配任何字母，后跟同一字母的零个或多个实例

rx=/（[a-zA-Z]）\1*/g

您的示例匹配[“eeeee”、“oooo”、“hh”、“ooo”、“ee”]

使用map，返回每个索引的首字母和新数组中的出现次数

function letterCount(str){
    var s= str.match(/([a-zA-Z])\1*/g)||[];
    return s.map(function(itm){
        return [itm.charAt(0), itm.length];
    });
}

信数（“eeeee-ooohooe”）

返回值：（数组）

[“e”，5]，“o”，4]，“h”，2]，“o”，3]，“e”，2]。

注:

var s=str.match（/（[a-zA-Z]）\1*/g）| |[]；

返回一个匹配数组（重复字母）或一个空数组（[]）。否则，如果字符串不包含任何字母，将抛出一个错误（在null上调用map）

\1*用于允许匹配具有任何或无顺序重复的单个字母的实例。“\1+”不会匹配单个未重复的字母

Arraymap需要一个函数并传递三个参数——每个索引的值、索引号和对整个数组的引用。在这种情况下，只使用每个索引的值，因此我们可以忽略其他参数

---

为了简单起见，我喜欢使用正则表达式，因为这很可能会导致更快的处理速度。此外，我以前从未使用过

map

。比我的答案要好得多：）如果有什么可以改进的，可能是创建一个额外的附件，这样匿名函数就不会在每次运行时声明。但是n这会让一切变得简单。感谢你们提供了这个漂亮的解决方案！匹配（[a-zA-Z]）\1*/g）和（[a-zA-Z]\1+/g）之间有什么不同在第二行？当前面的字符出现0次或更多次时，星号或星号*不使用吗？而在这种情况下，它应该出现1次或更多次，即与加号+一起使用？什么是“itm”代表？从本质上讲，第二行的内容是：s是给定字符串上的匹配方法，还是空数组，如果找不到匹配项？非常感谢您的澄清。我正在解释其他人的代码，但是；之所以使用星号，是因为算法连续地针对同一字符的零个或多个实例，需要to匹配没有连续相同字符序列的情况。语句

var s=str.match（/（[a-zA-Z]）\1*/g）| |[]；

基本上表示if

str.match（…）

返回一个伪值，例如

0

、

null

或

未定义的
以将空数组分配给
s
，而不是
str.match
返回的值。
function LetterCount(str) {
    var current, i = 0, l = str.length;
    var outputArr = [];
    while(i<l) {
        current = str.charAt(i);
        if(!i++ || outputArr[outputArr.length-1][0] !== current)
            outputArr[outputArr.length] = [current, 1];
        else outputArr[outputArr.length-1][1]++;
        }
    return outputArr;
    }

var letterCount = (function(){
    var r = /([A-z])\1*/g,
        f = function(itm){
        return [itm.charAt(0), itm.length];
        };
    return function letterCount(str){
        return str.match(r).map(f);
        };
    }());

// node v0.10.31
// assert v1.3.0

var assert = require('assert');

function letterCount(str) {
    var i = 0,
        seq = 0,
        results = [];

    while (i < str.length) {
        var current = str[i],
            next = str[i + 1];

        if (typeof results[seq] === 'undefined') {
            results[seq] = [current, 0];
        }

        results[seq][1]++;

        if (current !== next) {
            seq++;
        }

        i++;
    }

    return results;
}

var actual = letterCount('eeeeeoooohhoooee');
var expected = [["e", 5],["o",4],["h",2],["o",3],["e",2]];

assert.deepEqual(actual, expected);

function letterCount(str){
    var s= str.match(/([a-zA-Z])\1*/g)||[];
    return s.map(function(itm){
        return [itm.charAt(0), itm.length];
    });
}