從紅寶石

Question

替代的返回數組我想借此串foofoofoo，地圖foo到bar，並將所有個體替換爲一個數組 - ['barfoofoo', 'foobarfoo', 'foofoobar']

這是最好的我：

require 'pp' 
def replace(string, pattern, replacement) 
    results = [] 
    string.length.times do |idx| 
    match_index = (Regexp.new(pattern) =~ string[idx..-1]) 
    next unless match_index 
    match_index = idx + match_index 
    prefix = '' 
    if match_index > 0 
     prefix = string[0..match_index - 1] 
    end 

    suffix = '' 
    if match_index < string.length - pattern.length - 1 
     suffix = string[match_index + pattern.length..-1] 
    end 

    results << prefix + replacement + suffix 
    end 
    results.uniq 
end 

pp replace("foofoofoo", 'foo', 'bar') 

這起作用（至少對於這個測試用例來說），但是看起來太冗長而且很拗口。我可以做的更好，也許通過使用string#gsub與塊或其他？

Answer 1

這是很容易與pre_match（$`）和post_match（$'）做：

def replace_matches(str, re, repl) 
     return enum_for(:replace_matches, str, re, repl) unless block_given? 
     str.scan(re) do 
     yield "#$`#{repl}#$'" 
     end 
    end 

    str = "foofoofoo" 

    # block usage 
    replace_matches(str, /foo/, "bar") { |x| puts x } 

    # enum usage 
    puts replace_matches(str, /foo/, "bar").to_a 

編輯：如果你有重疊的比賽，那麼它會變得更難，因爲正則表達式並沒有真正具備處理它的能力。所以，你可以做這樣的：

def replace_matches(str, re, repl) 
    return enum_for(:replace_matches, str, re, repl) unless block_given? 
    re = /(?=(?<pattern>#{re}))/ 
    str.scan(re) do 
    pattern_start = $~.begin(0) 
    pattern_end = pattern_start + $~[:pattern].length 
    yield str[0 ... pattern_start] + repl + str[pattern_end .. -1] 
    end 
end 

str = "oooo" 
replace_matches(str, /oo/, "x") { |x| puts x } 

在這裏，我們濫用積極先行，這是0寬度，所以我們可以得到重疊的匹配。但是，我們還需要知道我們匹配了多少個字符，而我們現在無法像以前那樣匹配0個寬度，因此我們將重新捕獲該預測的內容，並計算新的寬度那。

（免責聲明：它仍然將只匹配每個字符一次;如果你想在每一個字符考慮多種可能性，就像你/f|o|fo/情況下，複雜的東西還多）

編輯：一個有點調整和我們甚至可以支持適當的GSUB類似的行爲：

def replace_matches(str, re, repl) 
    return enum_for(:replace_matches, str, re, repl) unless block_given? 
    new_re = /(?=(?<pattern>#{re}))/ 
    str.scan(new_re) do 
    pattern_start = $~.begin(0) 
    pattern_end = pattern_start + $~[:pattern].length 
    new_repl = str[pattern_start ... pattern_end].gsub(re, repl) 
    yield str[0 ... pattern_start] + new_repl + str[pattern_end .. -1] 
    end 
end 

str = "abcd" 
replace_matches(str, /(?<first>\w)(?<second>\w)/, '\k<second>\k<first>').to_a 
# => ["bacd", "acbd", "abdc"] 

（免責聲明：最後一個片段，該模式採用回顧後或先行到比賽區域外的檢查無法處理的情況下）

Answer 2

我想借此串foofoofoo，地圖FOO吧，並返回所有單個替換爲一個數組 - 如果我們假定[ 'barfoofoo'， 'foobarfoo'， 'foofoobar']

輸入總是正好是「foofoofoo」（三個「foo」），那麼問題很簡單，所以我們假設有一個或多個「foo」。

def possibilities(input) 
    n = input.length/3 
    n.times.map { |i| 
    (['bar'] + Array.new(n - 1, 'foo')).rotate(-i).join 
    } 
end 

possibilities "foo" 
# ["bar"] 
possibilities "foofoo" 
# ["barfoo", "foobar"] 
possibilities "foofoofoo" 
# ["barfoofoo", "foobarfoo", "foofoobar"] 

有一些解決方案會使用較少的內存，但是這種方法似乎很方便。

Answer 3

我不認爲Ruby提供了這種開箱即用的功能。然而，這裏是我的兩分錢，這可能是更優雅：

def replace(str, pattern, replacement) 
    count = str.scan(pattern).count 
    fragments = str.split(pattern, -1) 

    count.times.map do |occurrence| 
    fragments[0..occurrence].join(pattern) 
     .concat(replacement) 
     .concat(fragments[(occurrence+1)..count].to_a.join(pattern)) 
    end 
end