Ruby 数据格式化

Question

我正在读取一个日志文件并尝试以下面的格式组织数据，所以我想将 NAME(即 USOLA51、USOLA10..)作为哈希值推送并为 LIST 创建相应的数组和详情。我也创建了哈希，但不确定如何获取/提取相应/关联的数组值。

预期输出

NAME           LIST             DETAILS

USOLA51        ICC_ONUS         .035400391
               PA_ONUS          .039800391
               PA_ONUS          .000610352

USOLA10        PAL               52.7266846
              CFG_ONUS           15.9489746
likewise for the other values

日志文件:

--- data details ----

USOLA51

ONUS                    size
------------------------------ ----------
ICC_ONUS               .035400391
PA_ONUS            .039800391
PE_ONUS            .000610352

=========================================


---- data details ----


USOLA10


ONUS                    size
------------------------------ ----------
PAL                52.7266846
CFG_ONUS               15.9489746


=========================================

---- data details ----


USOLA55


ONUS                    size
------------------------------ ----------
PA_ONUS            47.4707031
PAL              3.956604
ICC_ONUS               .020385742
PE_ONUS            .000610352


=========================================


---- data details ----

USOLA56

ONUS                    size
------------------------------ ----------

=========================================

我尝试过的

unique = Array.new
owner = Array.new
db = Array.new
File.read("mydb_size.log").each_line do |line|
  next if line =~ /---- data details ----|^ONUS|---|=======/   
  unique << line.strip if line =~ /^U.*\d/ 

end

hash = Hash[unique.collect { |item| [item, ""] } ]

puts hash

当前营业额

{"USOLA51"=>"", "USOLA10"=>"", "USOLA55"=>"", "USOLA56"=>""}

任何对前进的帮助在这里都会非常有帮助。谢谢!!

Answer 1

虽然您的日志文件不是 CSV，但我发现 csv 库在很多非 csv 解析中很有用。您可以使用它来解析您的日志文件，方法是跳过空白行以及以 ---、=== 或 ONUS 开头的任何行>。您的列分隔符是一个空白字符:

csv = CSV.read("./example.log", skip_lines: /\A(---|===|ONUS)/,
               skip_blanks: true, col_sep: " ")

然后，一些行在解析出的数组中只有 1 个元素，这些是您的标题行。因此，我们可以根据只有 1 个元素的情况将 csv 数组分成几组，并根据结果创建一个散列:

output_hash = csv.slice_before { |row| row.length == 1 }.
  each_with_object({}) do |((name), *rows), hash|
  hash[name] = rows.to_h
end

现在，很难判断您是想要哈希输出作为您显示的文本，还是只想要哈希。如果你想要文本输出，我们首先需要看看每列需要显示多少空间:

name_length = output_hash.keys.max_by(&:length).length
list_length = output_hash.values.flat_map(&:keys).max_by(&:length).length
detail_length = output_hash.values.flat_map(&:values).max_by(&:length).length

format = "%-#{name_length}s %-#{list_length}s %-#{detail_length}s"

然后我们可以输出标题行和 output_hash 中的所有值，但前提是它们有任何值:

puts("#{format}\n\n" % ["NAME", "LIST", "DETAILS"])

output_hash.reject { |name, values| values.empty? }.each do |name, values|
  list, detail = values.first
  puts(format % [name, list, detail])

  values.drop(1).each do |list, detail|
    puts(format % ['', list, detail])
  end

  puts
end

结果:

NAME    LIST     DETAILS   

USOLA51 ICC_ONUS .035400391
        PA_ONUS  .039800391
        PE_ONUS  .000610352

USOLA10 PAL      52.7266846
        CFG_ONUS 15.9489746

USOLA55 PA_ONUS  47.4707031
        PAL      3.956604  
        ICC_ONUS .020385742
        PE_ONUS  .000610352

---

有点难以解释(对我来说)什么是slice_before做。但是，它需要一个数组(或其他可枚举的)并创建其元素的组或 block ，其中第一个元素与参数匹配或 block 返回 true。例如，如果我们有一个较小的数组:

array = ["slice here", 1, 2, "slice here", 3, 4]
array.slice_before { |el| el == "slice here" }.entries
# => [["slice here", 1, 2], ["slice here", 3, 4]]

我们告诉 slice_before，我们希望每个组都以等于“slice here”的元素开始，所以我们返回了 2 个组，每组中的第一个元素是“slice here”，其余元素elements 是数组中的所有元素，直到它下次看到“slice here”为止。

那么，我们可以获取该结果并调用 each_with_object在它上面，传递一个空的散列开始。对于 each_with_object，第一个参数将是数组的元素(来自每个)，第二个参数将是您传递的对象。当 block 参数看起来像 |((name), *rows), hash| 时会发生什么，第一个参数(数组的元素)被解构为数组的第一个元素，其余的元素:

# the array here is what gets passed to `each_with_object` for the first iteration as the first parameter
name, *rows = [["USOLA51"], ["ICC_ONUS", ".035400391"], ["PA_ONUS", ".039800391"], ["PE_ONUS", ".000610352"]]
name # => ["USOLA51"]
rows # => [["ICC_ONUS", ".035400391"], ["PA_ONUS", ".039800391"], ["PE_ONUS", ".000610352"]]

然后，我们再次解构第一个元素，这样我们就不会将它放在数组中:

name, * = name # the `, *` isn't needed in the block parameters, but is needed when you run these examples in irb
name # => "USOLA51"

对于max_by(&:length).length ，我们所做的就是找到数组中最长的元素(由 keys 或 values 返回)并获取它的长度:

output_hash = {"USOLA51"=>{"ICC_ONUS"=>".035400391", "PA_ONUS"=>".039800391", "PE_ONUS"=>".000610352"}, "USOLA10"=>{"PAL"=>"52.7266846", "CFG_ONUS"=>"15.9489746"}, "USOLA55"=>{"PA_ONUS"=>"47.4707031", "PAL"=>"3.956604", "ICC_ONUS"=>".020385742", "PE_ONUS"=>".000610352"}, "USOLA56"=>{}}
output_hash.values.flat_map(&:keys)
# => ["ICC_ONUS", "PA_ONUS", "PE_ONUS", "PAL", "CFG_ONUS", "PA_ONUS", "PAL", "ICC_ONUS", "PE_ONUS"]
output_hash.values.map(&:length) # => [8, 7, 7, 3, 8, 7, 3, 8, 7]
output_hash.values.flat_map(&:keys).max_by(&:length) # => "ICC_ONUS"
output_hash.values.flat_map(&:keys).max_by(&:length).length # => 8