Ruby 循环输出重复项

Question

如何停止此代码输出中的重复项。

RE = /<("[^"]*"|'[^']*'|[^'">])*>/
TAG_RE = /<(.+?)>(.*?)<.+?>/

text = "<date>show</date> me the current conditions for <city> detroit <END>"
a = []

text.scan(TAG_RE).map { |w| a<< w; }

text.gsub(RE, '').split.each do |q|
    a.each_with_index do |v, i|
        if q == a[i].last.strip
            puts "#{q}\tB-#{a[i].first}"        
        else
            puts "#{q}\tO"          
        end

    end
end

输出

show    B-date
show    O
me  O
me  O
the O
the O
current O
current O
conditions  O
conditions  O
for O
for O
detroit O
detroit B-city

如果符合条件，我只想要单词的单个实例

像这样

show    B-date
me  O
the  O
current   O
conditions   O
for  O
detroit B-city

我可以把 next 放在循环的什么地方？

编辑
这段代码是 Rubyiotic 的吗？

text.gsub(RE, '').split.each do |q|
    a.each_with_index do |v, i|
        @a = a[i].last.strip # save in a variable    
        if @a == q
            puts "#{q}\tB-#{a[i].first}"    
            break # break inner loop if match found
        end
    end
    next if @a == q #skip current outer loop if match found
    puts "#{q}\tO"  
end

Answer 1

问题是您还迭代了您的 a，它实际上是标签和单词之间的散列。

如果您将扫描视为散列而不是数组，那么您就不会得到重复项。

RE = /<("[^"]*"|'[^']*'|[^'">])*>/
TAG_RE = /<(.+?)>(.*?)<.+?>/

text = "<date>show</date> me the current conditions for <city> detroit <END>"

a = text.scan(TAG_RE)

text.gsub(RE, '').split.each do |q|
  d = a.find { |p| p.last.strip == q }
  if d
    puts "#{q}\tB-#{d.first}"
  else
    puts "#{q}\tO"
  end
end

输出:

show    B-date
me      O
the     O
current O
conditions      O
for     O
detroit B-city

而且，当我们这样做时，您可以使用适当的 hash:

RE = /<("[^"]*"|'[^']*'|[^'">])*>/
TAG_RE = /<(.+?)>(.*?)<.+?>/

text = "<date>show</date> me the current conditions for <city> detroit <END>"

map = Hash[*text.scan(TAG_RE).flatten.map(&:strip)].invert

text.gsub(RE, '').split.each do |q|
  tag = map[q]
  if tag
    puts "#{q}\tB-#{tag}"
  else
    puts "#{q}\tO"
  end
end

生成相同的输出。

编辑:如果您想了解更像 Ruby 的风格，我可能会这样做:

class Text
  TAGS_RE = /<("[^"]*"|'[^']*'|[^'">])*>/
  TAGS_WORDS_RE = /<(.+?)>\s*(.*?)\s*<.+?>/

  def self.strip_tags(text)
    text.gsub(TAGS_RE, '')
  end

  def self.tagged_words(text)
    matches = text.scan(TAGS_WORDS_RE)
    Hash[*matches.flatten].invert
  end
end

class Word
  def self.display(word, tag)
    puts "#{word}\t#{Word.tag(tag)}"
  end

  private

  def self.tag(tag)
    tag ? "B-#{tag}" : "0"
  end
end

text = "<date>show</date> me the current conditions for <city> detroit <END>"

words_tag = Text.tagged_words(text)
Text.strip_tags(text).split.each do |word|
  tag = words_tag[word]
  Word.display(word, tag)
end

为什么？

我不是那么聪明而且我很懒惰，所以我更喜欢把事情写得尽可能明确。所以，我尽量避免循环。

编写循环很容易，但阅读循环并不容易，因为在继续阅读和解析源代码的同时，您必须保持所阅读内容的上下文。

通常，带有 break 和 next 的循环更难解析，因为您必须跟踪哪些代码路径突然结束了循环。

嵌套循环更加困难，因为您必须跟踪多个以不同速度变化的上下文。

我相信提议的版本更易于阅读，因为每一行都可以单独理解。从一行转到下一行时，我们需要记住的上下文很少。

细节抽象在方法中，所以如果你只是想了解大局，可以看代码的主要部分:

words_tag = Text.tagged_words(text)
Text.strip_tags(text).split.each do |word|
  tag = words_tag[word]
  Word.display(word, tag)
end

如果您想了解它是如何完成的细节，您可以查看这些方法是如何实现的。通过这种方法，实现细节不会泄露到可能不需要的地方。

我认为这在所有编程语言中都是一种很好的做法，而不仅仅是在 Ruby 中。