Question

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

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

我想在XML中搜索字符串，但可能包含多行标记，多个块文档和/或多个页面标记：

<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 is 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>

当我搜索“制作高的方法”时，map{|f| f.text}返回：

["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搜索来提取所有>>> mylist=[1,7,8,7,7] >>> mylist.count(7) 3元素。然后，将每个元素分解为该节点中包含的单词，这样我们就可以匹配仅与节点的一部分匹配的短语。然后，连续订购单词，使用line（其中each_cons(4)是您要搜索的单词数）查看所有连续的四个单词集，如果它们与您的搜索匹配则返回连接时的字符串。这是我的代码：

产生：

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

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中则很方便。如果没有，则删除行以捕获这些参数，并仅返回文本：

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

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

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

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逐行搜索

2 个答案: