我不完全理解这个问题，但我认为建议您如何处理一个更基本的问题很重要：以有效且类似于 Ruby 的方式从文件的每一行中提取所需的信息。一旦你有了这些信息，以散列数组的形式，每行一个散列，你可以用它做你想做的事。或者，您可以遍历文件中的行，为每一行构造一个哈希，并在继续下一行之前执行任何所需的操作。
作为 Ruby 新手，您无疑会发现下面的一些代码难以理解。但是，如果你坚持下去，我想你将能够理解所有这些，并在这个过程中学到很多关于 Ruby 的知识。我在回答的最后部分提出了一些建议，以帮助您破译密码。
代码
words_by_key = {
type: %w| sedan coupe hatchback station suv |,
transmission: %w| auto manual steptronic |,
drivetrain: %w| fwd rwd awd |,
status: %w| used new |,
car_maker: %w| honda toyota mercedes bmw lexus |,
model: %w| camry clk crv |
}
#=> {:type=>["sedan", "coupe", "hatchback", "station", "suv"],
# :transmission=>["auto", "manual", "steptronic"],
# :drivetrain=>["fwd", "rwd", "awd"],
# :status=>["used", "new"],
# :car_maker=>["honda", "toyota", "mercedes", "bmw", "lexus"],
# :model=>["camry", "clk", "crv"]}
WORDS_TO_KEYS = words_by_key.each_with_object({}) { |(k,v),h| v.each { |s| h[s] = k } }
#=> {"sedan"=>:type, "coupe"=>:type, "hatchback"=>:type, "station"=>:type, "suv"=>:type,
# "auto"=>:transmission, "manual"=>:transmission, "steptronic"=>:transmission,
# "fwd"=>:drivetrain, "rwd"=>:drivetrain, "awd"=>:drivetrain,
# "used"=>:status, "new"=>:status,
# "honda"=>:car_maker, "toyota"=>:car_maker, "mercedes"=>:car_maker,
# "bmw"=>:car_maker, "lexus"=>:car_maker,
# "camry"=>:model, "clk"=>:model, "crv"=>:model}
module ExtractionMethods
def km(str)
str[/\A\d+(?=km\z)/]
end
def year(str)
str[/\A\d+{4}\z/]
end
def stock(str)
return nil if str.end_with?('km')
str[/\A\d+\p{Alpha}\p{Alnum}*\z/]
end
def trim(str)
str[/\A\p{Alpha}{2}\z/]
end
def fuel_consumption(str)
str.to_f if str[/\A\d+(?:\.\d+)?(?=l\/100km\z)/]
end
end
class K
include ExtractionMethods
def extract_hashes(fname)
File.foreach(fname).with_object([]) do |line, arr|
line = line.downcase
idx_left = line.index('{')
idx_right = line.index('}')
if idx_left && idx_right
g = { set_of_features: line[idx_left..idx_right] }
line[idx_left..idx_right] = ''
line.squeeze!(',')
else
g = {}
end
arr << line.split(',').each_with_object(g) do |word, h|
word.strip!
if WORDS_TO_KEYS.key?(word)
h[WORDS_TO_KEYS[word]] = word
else
ExtractionMethods.instance_methods.find do |m|
v = public_send(m, word)
(h[m] = v) unless v.nil?
v
end
end
end
end
end
end
示例
data =<<BITTER_END
65101km,Sedan,Manual,2010,18131A,FWD,Used,5.5L/100km,Toyota,camry,SE,{AC, Heated Seats, Heated Mirrors, Keyless Entry}
coupe,1100km,auto,RWD, Mercedec,CLK,LX ,18FO724A,2017,{AC, Heated Seats, Heated Mirrors, Keyless Entry, Power seats},6L/100km,Used
AWD,SUV,0km,auto,new,Honda,CRV,8L/100km,{Heated Seats, Heated Mirrors, Keyless Entry},19BF723A,2018,LE
BITTER_END
FILE_NAME = 'temp'
File.write(FILE_NAME, data)
#=> 353 (characters written to file)
k = K.new
#=> #<K:0x00000001c257d348>
k.extract_hashes(FILE_NAME)
#=> [{:set_of_features=>"{ac, heated seats, heated mirrors, keyless entry}",
# :km=>"65101", :type=>"sedan", :transmission=>"manual", :year=>"2010",
# :stock=>"18131a", :drivetrain=>"fwd", :status=>"used", :fuel_consumption=>5.5,
# :car_maker=>"toyota", :model=>"camry", :trim=>"se"},
# {:set_of_features=>"{ac, heated seats, heated mirrors, keyless entry, power seats}",
# :type=>"coupe", :km=>"1100", :transmission=>"auto", :drivetrain=>"rwd",
# :model=>"clk", :trim=>"lx", :stock=>"18fo724a", :year=>"2017",
# :fuel_consumption=>6.0, :status=>"used"},
# {:set_of_features=>"{heated seats, heated mirrors, keyless entry}",
# :drivetrain=>"awd", :type=>"suv", :km=>"0", :transmission=>"auto",
# :status=>"new", :car_maker=>"honda", :model=>"crv", :fuel_consumption=>8.0,
# :stock=>"19bf723a", :year=>"2018", :trim=>"le"}]
说明
首先，请注意，HEREDOC 在执行之前需要取消缩进。
你会看到实例方法K#extract_hashes使用IO#foreach逐行读取文件。1
处理文件每一行的第一步是将其小写。然后，您将希望用逗号分割字符串以形成单词数组。但是，存在一个问题，因为您不想在左右大括号（{ 和 }）之间的逗号上拆分，这对应于键 :set_of_features。我决定通过确定两个大括号的索引来处理这个问题，使用单个键 :set_of_features 创建一个哈希，从该行中删除该子字符串，最后用一个逗号替换一对相邻的逗号：
idx_left = line.index('{')
idx_right = line.index('}')
if idx_left && idx_right
g = { set_of_features: line[idx_left..idx_right] }
line[idx_left..idx_right] = ''
line.squeeze!(',')
else
g = {}
end
请参阅 String 了解此处和其他地方使用的 String 方法的文档。
我们现在可以将生成的line 转换为通过逗号分隔的单词数组。如果输出中需要任何大小写，则应在构造哈希后完成。
我们将建立在刚刚创建的哈希 { set_of_features: line[idx_left..idx_right] } 之上。完成后，它将被附加到返回的数组中。
然后处理数组中的每个元素 (word)。如果是我们设置的哈希WORDS_TO_KEYS的key
h[WORDS_TO_KEYS[word]] = word
并用那个词完成。如果没有，我们在模块ExtractionMethods 中执行每个实例方法m，直到找到一个m[word] 不是nil。当发现另一个键值对被添加到哈希h：
h[m] = word
请注意，ExtractionMethods 中每个实例方法的名称，它是一个符号（例如，:km），是散列 h 中的一个键。拥有单独的方法有助于调试和测试。
我本来可以写的：
if (s = km(word))
s
elsif (s = year(word))
s
elsif (s = stock(str))
s
elsif (s = trim(str))
s
elsif (s = fuel_consumption(str))
s
end
但由于所有这些方法都采用相同的参数word，我们可以改为使用Object#public_send：
a = [:km, :year, :stock, :trim, :fuel_consumption]
a.find do |m|
v = public_send(m, word)
(h[m] = v) unless v.nil?
v
end
最后的调整是将数组a 中的所有方法放入模块ExtractionMethods 中，并将该模块包含在类K 中。然后我们可以将上面find 表达式中的a 替换为ExtractionMethods.instance_methods。 （见Module#instance_methods。）
现在假设数据已更改，因此添加了其他字段（例如，“颜色”或“价格”）。那么唯一对代码的修改是对words_by_key的更改和/或向ExtractionMethods添加方法。
理解代码
在插入puts 语句的情况下运行代码可能会有所帮助。例如，
idx_left = line.index('{')
idx_right = line.index('}')
puts "idx_left=#{idx_left}, idx_left=#{idx_left}"
在代码被链接的地方，用临时变量将其分解并插入puts 语句可能会有所帮助。例如，改变
arr << line.split(',').each_with_object(g) do |word, h|
...
到
a = line.split(',')
puts "line.split(',')=#{a}"
enum = a.each_with_object(g)
puts "enum.to_a=#{enum.to_a}"
arr << enum do |word, h|
...
这里的第二个puts只是看看枚举器enum会生成什么元素并传递给block。
另一种方法是使用方便的方法Object#tap，它插入在两个方法之间：
arr << line.split(',').tap { |a| puts "line.split(',')=#{a}"}.
each_with_object(g) do |word, h|
...
tap（伟大的名字，嗯？）在这里使用，只是在显示其值后返回其接收者。
最后，我在几个地方使用了Enumerable#each_with_object 方法。它可能看起来很复杂，但实际上非常简单。例如，
arr << line.split(',').each_with_object(g) do |word, h|
...
end
实际上等同于：
h = g
arr << line.split(',').each do |word|
...
end
h
1 许多IO 方法通常在File 上调用。这是可以接受的，因为File.superclass #=> IO.