从一个文件中读取字符串并添加到另一个文件中，并添加后缀以使其唯一

Question

我正在用 ruby​​ 处理文档。

我有一个文档，我正在使用正则表达式提取特定字符串，然后将它们添加到另一个文件中。添加到目标文件时，它们必须是唯一的，因此如果该字符串已存在于目标文件中，我将添加一个简单的后缀，例如 _1。最终我想按名称引用字符串，因此随机数生成或日期字符串是不好的。

目前，我将添加的每个单词存储在一个数组中，然后每次添加一个单词时，我都会检查该字符串是否存在于数组中，如果只有 1 个重复项就很好，但可能有 2 个或更多，所以我需要检查对于初始字符串，然后循环递增后缀直到它不存在，（我简化了我的代码，因此可能存在错误）

def add_word(word) 
  if @added_words include? word
    suffix = 1
    suffixed_word = word
    while added_words include? suffixed_word
      suffixed_word = word + "_" + suffix.to_s
      suffix += 1
    end
    word = suffixed_word                 
  end
  @added_words << word
end

它看起来很乱，是否有更好的算法或 ruby​​ 方法来做到这一点？

Answer 1

将@added_words设置为一个集合（不要忘记require 'set'）。这使得查找速度更快，因为集合是通过哈希实现的，同时仍然使用 include? 来检查集合成员资格。提取使用最多的后缀也很容易：

>> s << 'foo' 
#=> #<Set: {"foo"}>
>> s << 'foo_1' 
#=> #<Set: {"foo", "foo_1"}>
>> word = 'foo'
#=> "foo"
>> s.max_by { |w| w =~ /#{word}_?(\d+)?/ ; $1 || '' } 
#=> "foo_1"
>> s << 'foo_12' #=> 
#<Set: {"foo", "foo_1", "foo_12"}>
>> s.max_by { |w| w =~ /#{word}_?(\d+)?/ ; $1 || '' } 
#=> "foo_12"

现在要获取可以插入的下一个值，您只需执行以下操作（假设您已经有 12 个 foo，因此下一个应该是 foo_13)：

>> s << s.max_by { |w| w =~ /#{word}_?(\d+)?/ ; $1 || '' }.next 
#=> #<Set: {"foo", "foo_1", "foo_12", "foo_13"}

抱歉，如果这些例子有点混乱，我今天早些时候有麻醉。这应该足以让您了解集合如何可能对您有帮助（其中大多数也可以与数组一起使用，但集合的查找速度更快）。

Answer 2

将 @added_words 更改为默认值为零的哈希值。然后你可以这样做：

@added_words = Hash.new(0)

def add_word( word)
  @added_words[word] += 1
end

# put it to work:

list = %w(test foo bar test bar bar)
names = list.map do |w|
  "#{w}_#{add_word(w)}"
end
p @added_words
#=> {"test"=>2, "foo"=>1, "bar"=>3}
p names
#=>["test_1", "foo_1", "bar_1", "test_2", "bar_2", "bar_3"]

Answer 3

在这种情况下，我可能会使用集合或散列：

#in your class:
require 'set'
require 'forwardable'
extend Forwardable #I'm just including this to keep your previous api

#elsewhere you're setting up your instance_var, it's probably [] at the moment
def initialize
   @added_words = Set.new
end

#then instead of `def add_word(word); @added_words.add(word); end`:
def_delegator :added_words, :add_word, :add 
#or just change whatever loop to use #@added_words.add('word') rather than self#add_word('word')
#@added_words.add('word') does nothing if 'word' already exists in the set.

如果您有一些通过这些部分分组的属性，那么散列可能会更好：

#elsewhere you're setting up your instance_var, it's probably [] at the moment
def initialize
   @added_words = {}
end

def add_word(word, attrs={})
   @added_words[word] ||= []
   @added_words[word].push(attrs)
end

Answer 4

以“错误的方式”进行操作，但代码稍微好一些：

def add_word(word) 
  if @added_words.include? word
    suffixed_word = 1.upto(1.0/0.0) do |suffix|
      candidate = [word, suffix].join("_")
      break candidate unless @added_words.include?(candidate)
    end
    word = suffixed_word
  end
  @added_words << word
end