Javascript：for循环完成后将最终元素添加到数组

Question

预期结果说明

我的来源是超过 30,000 行非常结构化的文本，前面的数字递增，后面的数字递增，并用冒号分隔。去掉非必需项，我留下了以下 sourceArray，为方便起见被截断:)

sourceArray = ["001:001", "001:002", "001:003", 
               "002:001", "002:002", 
               "003:001", "003:002"]; 

我正在尝试计算每个前数的后数并将其推送到数组中。在伪代码中，我的最终结果应该是这样的：

myArray[totalNumberOf_001_Items, totalNumberOf_002_Items, totalNumberOf_003_Items]

在我的简单示例中，最终值应该是：

[3, 2, 2]

问题和疑问

我的 for 循环在我的数据末尾结束，因此我的数组中缺少一个元素。

如何在循环中进行“额外的传递”，或者是否有其他方法可以将最终元素推送到我的数组？

var sourceArray = ["001:001", "001:002", "001:003",
  "002:001", "002:002",
  "003:001", "003:002"
];
var myArray = [];
var frontCounter = 1;
var backCounter = 1;

for (var i = 0; i < sourceArray.length; i++) {
  var text = sourceArray[i];
  var front = text.substr(0, 3);
  front = Number(front);
  var back = text.substr(4, 3);
  back = Number(back);

  if (front == frontCounter) {
    backCounter++;
  } else {
    myArray.push(backCounter - 1);
    backCounter = 2;
    frontCounter++;
  }
}
console.log(myArray); // result [3, 2]

Answer 1

您可以使用如下所示的对象来跟踪一段文本出现的次数，文本将是键，值是它们出现的次数。从中你可以构建你的数组

var sourceArray = ["001:001", "001:002", "001:003", 
                   "002:001", "002:002", 
                   "003:001", "003:002"]; 

var frontEncounters = {};

function updateFrontEncounters(frontEncounters, front){
    var keys = Object.keys(frontEncounters);
    if(keys.indexOf(front) == -1)
    {
        frontEncounters[front] = 1;
    }
    else
    {
        frontEncounters[front] += 1;
    }
}

for(var item in sourceArray){
    var text = sourceArray[item];
    var front = text.substr(0, 3);
    var back = text.substr(4, 3);
    updateFrontEncounters(frontEncounters, front);  
}

var keys = Object.keys(frontEncounters);
var myArr = [];

for(var key in keys)
{
    myArr.push(frontEncounters[keys[key]])
}
console.log(myArr);

Answer 2

使用一个对象来存储“前”数字及其计数。

for (var i = 0; i < sourceArray.length; i++) {
    var num = sourceArray[i].slice(0,3);
    counts[num] = counts[num] ? counts[num]+1 : 1;
}

完成后，您可以非常轻松地将其转换为数组：

var result = Object.keys(counts).map(function (key) {
    return counts[key];
});

有了 ES-2017，就更简单了：

var result = Object.values(counts)

工作片段：

var sourceArray = ["001:001", "001:002", "001:003", 
                   "002:001", "002:002", 
                   "003:001", "003:002"]; 
var counts = {};

for (var i = 0; i < sourceArray.length; i++) {
    var num = sourceArray[i].slice(0,3);
    counts[num] = counts[num] ? counts[num]+1 : 1;
}
console.log(counts);
var result = Object.keys(counts).map(function (key) {
    return counts[key];
});
console.log(result);

// ES-2017
//console.log(Object.values(counts));

Answer 3

这是您可以使用的替代方法，这样您就不必遍历行的整个源代码 (30,000) 。使用 while 循环，以便在到达 0 时立即中断；使用Map 来存储唯一编号，方法是将索引/frontnumber 设为key，并将其value 设为用作计数器以跟踪其总数的对象。如果key存在，更新总数；如果没有，则创建一个新的计数器对象。然后只需返回Map，通过map'将其转换为所需的数组，将其转换为仅包含总数的数组。

var sourceArray = ["001:001", "001:002", "001:003",
  "002:001", "002:002",
  "003:001", "003:002"
];

function getTotal(sourceArray) {

  let count = new Map();
  let update = item => count.get(item).total++;
  let create = item => count.set(item, {total: 1});

  const getItem = index => {
    let text = sourceArray[index];
    return text.substr(0, 3);
  }

  let index = -1;
  let start = 0;
  
  while (index != 0 && start < sourceArray.length) {
    index = getItem(start++);
    count.has(index) ? update(index) : create(index);
  }

  return [...count.values()].map(item => item.total);
}

console.log(getTotal(sourceArray));