JavaScript函数，用于自动计数字符串中的连续字母

JavaScript function to automatically count consecutive letters in a string

本文关键字：字符串 连续 数字 函数 用于 JavaScript      更新时间：2024-03-11

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

理想情况下：LetterCount（"eeeee-oooohhoooee"）=[["e"，5]，["o"，3]，["h"，2]，["o"，3]

以下代码试图计算字符串中连续字母的数量，只有当我已经知道它们是什么时：

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

在上面的代码中，我需要首先知道字符串中的字母是什么，以及它们中有多少个，以什么顺序出现。

INSTEAD：如何编写一个函数，自动识别字母本身，然后返回连续字母的计数。如果答案是以下格式，那也太好了：

 LetterCount("eeeeeoooohhoooee") = [["e", 5],["o",3],["h",2],["o",3],["e",2]]

非常感谢您的帮助！

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

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];
  });
}
console.log(letterCount("eeeeeoooohhoooee"))

返回值：（数组）

[["e"，5]，["o"，4]，["h"，2]，["o"，3]，["e"

注意：

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

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

  1. ''1*用于允许匹配单个字母的实例，其中有任何或没有顺序重复。'''"1+"将与单个未复制的字母不匹配。

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

实际上"固定"了["o",3]到["o",4]；）

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

作为对kennebec（真棒）答案的修改，这样就不会在每次调用父函数时声明匿名函数。这只是为了参考与纯粹的简单性相比更好的编程实践（这可能是最有效的方法）：

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

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

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

function LetterCount(text){
    arr = [];
    letter = text[0];
    counter = 0;
    for (c in text+' '){
        if (text[c] != letter){
            newArr = [letter, counter];
            arr.push(newArr);
            letter = text[c];
            counter = 0;
        }
        counter += 1;
    };
    return arr;
}


const string = 'acbbaeekzzkeee';
function letterCount(str) {
  return [...str].reduce((acc, letter, index) => {
    if (index === 0 || letter !== str[index - 1]) {
      acc.push([letter, 1]);
    } else {
      acc[acc.length - 1][1]++;
    }
    return acc;
  }, []);
}
const count = letterCount(string);
console.log(count);

  1. 。。。将字符串排列成数组
  2. 使用reduce循环，初始值为空数组
  3. 如果是第一个字母或前一个字母与字母不相同
  4. 用[letter，1]创建一个数组，并将其推入累加器数组（1是初始计数/值）
  5. 否则递增累加器数组中上一个数组的值。由于上一个数组将具有与当前字母相同的字母
  • 所以，每当我们有新的值（非连续）时，我们都会在数组中添加一个数组
  • 否则，我们增加最后一个数组的值（它将是相同的字母）
相关文章：