我有以下 JSON 文件:

sensorlogs.json
{"arr":[{"UTCTime":10000001,"s1":22,"s2":32,"s3":42,"s4":12},
{"UTCTime":10000002,"s1":23,"s2":33,"s4":13},
{"UTCTime":10000003,"s1":24,"s2":34,"s3":43,"s4":14},
{"UTCTime":10000005,"s1":26,"s2":36,"s3":44,"s4":16},
{"UTCTime":10000006,"s1":27,"s2":37,"s4":17},
{"UTCTime":10000004,"s1":25,"s2":35,"s4":15},
...
{"UTCTime":12345678,"s1":57,"s2":35,"s3":77,"s4":99}
]}

传感器 s1、s2、s3 等都以不同的频率传输(请注意，s3 每 2 秒传输一次，时间戳可能是乱序的)。

我怎样才能实现类似的东西 -

Analyzing s1:
s = [[10000001, 22], [10000002, 23],.. [12345678,57]]
s1 had 2 missing entries
Analyzing s2:
s = [[10000001, 32], [10000002, 33],.. [12345678,35]]
s2 had 0 missing entries
Analyzing s3:
s = [[10000001, 42], [10000003, 43],.. [12345678,77]]
s3 had 0 missing entries
Analyzing s4:
s = [[10000001, 12], [10000003, 13],.. [12345678,99]]
s4 had 1 missing entries

sensorlogs.json 是 16 GB。

可以根据连续 UTC 时间戳的差异找到缺失的条目。每个传感器都以已知频率传输。

由于内存限制，我无法使用多个大型数组进行分析，因此我将不得不对同一个 JSON 日志文件进行多次传递，并仅使用一个大型数组进行分析。

我现在所拥有的是以下 -

var result = [];
//1. Extract all the keys from the log file
console.log("Extracting keys... \n");
var stream = fs.createReadStream(filePath);
var lineReader = lr.createInterface(
{
  input: stream
});

lineReader.on('line', function (line) 
{
  getKeys(line);//extract all the keys from the JSON
});
stream.on('end', function()
{
  //obj -> arr
  for(var key in tmpObj)
    arrStrm.push(key);

  //2. Validate individual sensors
  console.log("Validating the sensor data ...\n");

  //Synchronous execution of the sensors in the array
  async.each(arrStrm, function(key)
  {
    {
        currSensor = key;
        console.log("validating " + currSensor + "...\n");

        stream = fs.createReadStream(filePath);
        lineReader = lr.createInterface(
        {
          input: stream
        });

        lineReader.on('line', function (line) 
        {
          processLine(line);//Create the arrays for the sensors
        });
        stream.on('end', function()
        {
            processSensor(currSensor);//Process the data for the current sensor
        });
    }
  });
});

function getKeys(line) 
{
    if(((pos = line.indexOf('[')) >= 0)||((pos = line.indexOf(']')) >= 0))
        return;
    if (line[line.length-1] == '\r') line=line.substr(0,line.length-1); // discard CR (0x0D)
    if (line[line.length-1] == ',') line=line.substr(0,line.length-1); // discard ,
//  console.log(line);

    if (line.length > 1) 
    { // ignore empty lines
        var obj = JSON.parse(line); // parse the JSON
        for(var key in obj) 
        {
            if(key != "debug")
            {
                if(tmpObj[key] == undefined)
                    tmpObj[key]=[];
            }
        };
    }
}

当然这行不通，而且我无法在网上找到任何解释如何实现它的内容。

注意: 我可以选择我选择的任何语言来开发这个工具(C/C++、C#/Java/Python)，但我会使用 JavaScript，因为它能够轻松解析 JSON 数组(而且我也有兴趣在 JS 中变得更好). 如果 JavaScript 不是制作此类工具的最佳语言，是否有人愿意推荐一种替代语言来执行此操作？

编辑: 一些不是很清楚或者我之前没有包含的重要信息，但看起来包含在问题中很重要 -

1. JSON 日志中的数据不是实时流式传输，而是存储在硬盘中的 JSON 文件
2. 存储的数据未按时间顺序排列，这意味着时间戳的顺序可能不正确。所以每个传感器数据都需要根据时间戳进行排序after它被存储在一个数组中
3. 我不能为每个传感器使用单独的数组(这与在 RAM 中存储整个 16 GB JSON 相同)，并且为了节省内存，一次只能使用一个数组。是的，我的日志中有超过 4 个传感器，这只是一个示例(大约 20 个可以给出一个想法)

我已经修改了我的 JSON 和预期的输出

一种解决方案可能是对 JSON 文件进行多次传递，一次将一个带有时间戳的传感器数据存储在一个数组中，然后对数组进行排序，最后分析数据是否损坏和缺口。这就是我在上面的代码中尝试做的事情

最佳答案

所以你有 16GB 的大胖传感器日志包裹在 json 中。

首先，一个 16GB 的完整 json 文件是不现实的，因为左括号和右括号打破了规则，变成了数组中令人讨厌的字符。我们知道文件有开头和结尾，而且，如果没有它们，您的程序可以处理文件 block ，甚至可以处理直接插入设备的流。所以让我们假设我们将要处理的是:

{"UTCTime":10000001,"s1":22,"s2":32,"s3":42,"s4":12},
{"UTCTime":10000002,"s1":23,"s2":33,"s4":13},
{"UTCTime":10000003,"s1":24,"s2":34,"s3":43,"s4":14},
...
{"UTCTime":12345678,"s1":57,"s2":35,"s3":77,"s4":99},

甚至在末尾添加或检测缺失的逗号应该不会太困难。

现在每一行都以相同的方式格式化，并且可以解释为 json。 问题是:传感器是否按预期输出数据？如果我们确定他们在正确的时间以正确的频率说话(案例 1)但有时他们可能会错过写作，那么一切都很好。但是，如果他们开始在时间范围内出现轻微的偏差(情况 2)，则需要某种启发式方法来恢复正确的线路频率，并且分析时间会更长。

如果我们不是实时处理这个，首先对文件进行简单的验证检查是判断是否在每个 freq 行上都找到了预期的传感器数据，对吗？

无论如何，由于它是一个非常大的文件，因此必须尽可能逐行处理。

在下面的程序中，我只考虑了情况 1，我们可以处理一个连续的流。

#!/usr/bin/python
import json

sensors={}
sensors['s1']=[1] # frequencies
sensors['s2']=[1]
sensors['s3']=[2]
sensors['s4']=[1]

# append data array and error counter at sensors[i]
# it holds [freq,err,data]
for k,v in sensors.iteritems(): sensors[k].extend([0,[]])
FRQ=0;ERR=1;DAT=2
print list(sorted(sensors.items()))
S=list(sorted(sensors.keys()))

with open('./sensors.json', "r") as stream:
    i=0
    for line in stream:
      if not line.rstrip(): continue # skip blank lines
      j=json.loads(line[:-2]) # skip comma and \n
      t=j["UTCTime"]
      for k in S:
          sensor=sensors[k]
          if i%sensor[FRQ]==0 : # every Nth iteration
            v=j.get(k)
            if v is None:
                sensor[ERR]+=1
                print k,"has",sensor[ERR],"missing entries"
            sensor[DAT].append([t,v]) # append that sensor data
            # filling up the memory...
      i+=1

for k,v in sorted(sensors.iteritems()): print k,sensors[k][DAT]
for k,v in sorted(sensors.iteritems()): print k,'had',sensors[k][ERR],"missing entries"

为了处理案例 2，我们将反转 None 检查与模数检查，验证传感器是否在不应该的情况下写入了某些内容，然后尝试检测偏移。

最后一点:您的程序可能会内存不足，因此将整个数据保存在内存中可能不是一个好主意。如果打算为每个传感器使用单独的阵列来进行进一步处理，将它们写入文件可能更明智。

关于javascript - node.js中一个大的json日志文件分析，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39461047/