对具有相同接口但不相同的对象求和

Question

我正在尝试创建一个程序来根据我设置的规则检查文档的出现次数。在正则表达式的帮助下，我检查了一些字段，如果存在特定字段，我可以计算它出现的次数，或者我创建更深入的扫描。有点混乱，不知道具体怎么解释。

我正在检查文本文件，但为了降低复杂性，我将使用数组。

我有以下数组：

let strings = [
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME2 ID: 10'
];

这是欲望输出：

[
  {
    "NAME": {
      "12": 3
    }
  },
  {
    "NAME2": {
      "10": 1
    }
  }
]

我的逻辑：

'use strict';

let patterns = [
  {
    'pattern': 'COMPANY:\\s*?([\\w]+)',
    'modifier': ''
  },
  {
    'pattern': 'ID:\\s*?([\\d]+)',
    'modifier': ''
  }
];

let strings = [
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME  ID: 12',
  'COMPANY: NAME2 ID: 10'
];

var SUPER = [];
var _data = {};

for (let string of strings) {

	let i      = 0;
	let length = patterns.length
  var root   = _data;

  for (i; i < length; i++) {

    let item   = patterns[i];

    let regex  = new RegExp(item.pattern, item.modifier);
    let result = regex.exec(string);


    if (i < patterns.length -1) {

    	root = root[result[1]] = {};

    } else {
      root  = root[result[1]] = 1;





      SUPER.push(_data);
      _data = {};
    }
  }
}


console.log(JSON.stringify(SUPER, null ,2));

现在我有这个差距，我需要检查对象是否已经存在，如果是，我只增加最后一项。

有什么想法或建议吗？？

谢谢。

Answer 1

这样的事情怎么样？

// This (big_hash) is where we will store the output
// Sample output:
// {
//   NAME: {
//     "12": 3
//   },
//   NAME2: {
//     "10": 1
//   }
// }
let big_hash = {};

for (let string of strings){

  let pattern_matches = [];

  for (let pattern of patterns){
    let regex = new RegExp(pattern.pattern, pattern.modifier);
    pattern_matches[pattern_matches.length] = regex.exec(string);
  }

  // if all the patterns matched
  if( pattern_matches.every( match => match ) ){
    // separate logic for the last match, because its value is not a hash
    last_match = pattern_matches.pop();

    some_node = big_hash;
    for(let match of pattern_matches){
      let key = match[1];
      some_node[ key ] = some_node[ key ] || {};
      some_node = some_node[ key ];
    }

    // for the last level matching, the default value is 0, not {}
    some_node[ last_match ] = some_node[ last_match ] || 0;
    some_node[ last_match ] = some_node[ last_match ] + 1;
  }
}