XML 逐行搜索

Question

我有一份 XML 文档，格式如下：

<document>
  <page>
    <column>
      <text>
        <par>
          <line></line>
        </par>
      </text>
    </column>
  </page>
</document>

我想在 XML 中搜索字符串，但可能在多行标签、多块文档、and/or 多页标签中：

<document>
  <page>
    <column>
      <text>
        <par>
          <line>Hello</line>
        </par>
      </text>
    </column>
    <column>
      <text>
        <par>
          <line>World</line>
        </par>
      </text>
    </column>
  </page>
  <page>
    <column>
      <text>
        <par>
          <line>What's</line>
          <line>Up?</line>
        </par>
      </text>
    </column>
  </page>
</document>

我需要搜索 "Hello World What's Up?" 并知道它在第 1 列的第 1 行、第 2 列的第 1 行和第 3 块的第 1-2 行（第 3 页第 1 块）。

我在行上有元数据告诉我它是什么行号，以及它属于什么列号，例如：

<line linenum="1" columnnum="2">World</line>

在不同的列中搜索该字词并能够了解它们属于哪些行和列的详细信息的最佳方式是什么？

我可以获得第一个词的所有实例，对每个实例进行迭代，然后查看以下词是否与搜索词相对应（逐词），如果该行中没有更多词，请转到下一行。如果不再有行，请转到下一个块。想法？

这里是示例 XML 代码的真实片段，以及脚本返回的内容：

<block>
  <text>
    <par>
      <line colnum="1" linenum="1">
        (12) United States Patent
      </line>
    </par>
    <par>
      <line colnum="1" linenum="2">
        Kar-Roy et al.
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line colnum="2" linenum="3">
        US007078310B1
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line colnum="3" linenum="4">
        (io) Patent No.: US 7,078,310 B1
      </line>
    </par>
    <par>
      <line colnum="3" linenum="5">
        (45) Date of Patent: Jul. 18,2006
      </line>
    </par>
  </text>
</block>
<block>
  <text>
    <par>
      <line>
        (54) METHOD FOR FABRICATING A HIGH
      </line>
      <line>
        DENSITY COMPOSITE MIM CAPACITOR
      </line>
    </par>
  </text>
</block>

当我搜索 "METHOD FOR FABRICATING A HIGH" 时，map{|f| f.text} returns:

["Kar-Roy et al.", "US007078310B1", "(io) Patent No.: US 7,078,310 B1", "(45) Date of Patent: Jul. 18,2006", "(54) METHOD FOR FABRICATING A HIGH"]

看起来是取了五个字的长度，不知道为什么在实际结果之前得到了四行。

Answer 1

这是我的想法：首先，将您的结构解析为像 Nokogiri 这样的 XML 解析器，然后使用 XPath 搜索提取所有 line 元素。然后，将每个元素分解为该节点中包含的单词，这样我们就可以匹配仅匹配节点一部分的短语。然后，连续排列单词，使用 each_cons(4)（其中 4 是您要搜索的单词数）查看所有连续的四个单词组，如果匹配则 return连接时的搜索字符串。这是我的代码：

xml = Nokogiri::XML.parse(doc)

search = "HIGH DENSITY"

# 1. break down all the lines into words tagged with their nodes
# 2. find matching subsequence
# 3. build up from nodes

nodes = xml.xpath('//line')
words = nodes.map do |n|
  words_in_node = n.text.split(' ').map(&:upcase) # split into words and normalize
  words_in_node.map { |word| { word: word, node: n } }
end
words = words.flatten # at this point we have a single, ordered list like [ {word: "foo", node: ...}, {word: "bar", node: ...} ]

keywords = search.split(' ').map(&:upcase)
result = words.each_cons(keywords.size).find do |sample|
  # Extract just the :word key from each hash, then compare to our search string
  sample_words = sample.map { |w| w[:word] }
  sample_words == keywords
end

if result
  puts "Found in these nodes:"
  puts result.map { |w| w[:node] }.uniq.inspect
  # you can find where each node was located via Nokogiri
else
  puts "No match"
end

产生：

Found in these nodes:
[#<Nokogiri::XML::Element:0x4ea323e name="line" children=[#<Nokogiri::XML::Text:0x4ea294c "\n        (54) METHOD FOR FABRICATING A HIGH\n      ">]>,
 #<Nokogiri::XML::Element:0x4ea3018 name="line" children=[#<Nokogiri::XML::Text:0x4ea2654 "\n        DENSITY COMPOSITE MIM CAPACITOR\n      ">]>]

Answer 2

如果我明白你想要什么，我会这样做：

require 'nokogiri'

doc = Nokogiri::XML(<<EOT)
<document>
  <page>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="1">Hello</line>
        </par>
      </text>
    </column>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="2">World</line>
        </par>
      </text>
    </column>
  </page>
  <page>
    <column>
      <text>
        <par>
          <line linenum="1" columnnum="3">What's</line>
          <line linenum="2" columnnum="3">Up?</line>
        </par>
      </text>
    </column>
  </page>
</document>
EOT

line_text = doc.search('column').map { |column| 
  column.search('line').map{ |line|
    {
      line: line['linenum'],
      column: line['columnnum'],
      text: line.text
    }
  }
}

此时line_text包含：

line_text 
# => [[{:line=>"1", :column=>"1", :text=>"Hello"}],
#     [{:line=>"1", :column=>"2", :text=>"World"}],
#     [{:line=>"1", :column=>"3", :text=>"What's"},
#      {:line=>"2", :column=>"3", :text=>"Up?"}]]

这是按 <column> 分组。元数据不是必需的，但如果它存在于 XML 中会很方便。如果没有，请删除捕获这些参数的行，只删除 return 文本：

line_text = doc.search('column').map { |column| 
  column.search('line').map{ |line|
    line.text
  }
}

line_text 
# => [["Hello"], ["World"], ["What's", "Up?"]]

line_text 现在是一个数组数组。外部数组中的每个元素表示一列，而该子数组中的元素是行，因此您可以使用更小的 returned 数组以及一些额外代码来跟踪事物：

line_text.each.with_index(1) do |column, column_num|
  column.each.with_index(1) do |text, line_num|
    puts "column: #{column_num} line: #{line_num} text: #{text}"
  end
end
# >> column: 1 line: 1 text: Hello
# >> column: 2 line: 1 text: World
# >> column: 3 line: 1 text: What's
# >> column: 3 line: 2 text: Up?

XML 逐行搜索

XML searching line by line

ruby

xml

ruby-on-rails

nokogiri