进行多个字符串替换的更快方法

Question

我需要做以下事情：

    static string[] pats = { "å", "Å", "æ", "Æ", "ä", "Ä", "ö", "Ö", "ø", "Ø" ,"è", "È", "à", "À", "ì", "Ì", "õ", "Õ", "ï", "Ï" };
    static string[] repl = { "a", "A", "a", "A", "a", "A", "o", "O", "o", "O", "e", "E", "a", "A", "i", "I", "o", "O", "i", "I" };
    static int i = pats.Length;
    int j;

     // function for the replacement(s)
     public string DoRepl(string Inp) {
      string tmp = Inp;
        for( j = 0; j < i; j++ ) {
            tmp = Regex.Replace(tmp,pats[j],repl[j]);
        }
        return tmp.ToString();            
    }
    /* Main flow processes about 45000 lines of input */

每行有 6 个元素通过 DoRepl。大约 300,000 个函数调用。每个执行 20 次 Regex.Replace，总计约 600 万次替换。

有没有更优雅的方法可以在更少的通行数中做到这一点？

Answer 1

static Dictionary<char, char> repl = new Dictionary<char, char>() { { 'å', 'a' }, { 'ø', 'o' } }; // etc...
public string DoRepl(string Inp)
{
    var tmp = Inp.Select(c =>
    {
        char r;
        if (repl.TryGetValue(c, out r))
            return r;
        return c;
    });
    return new string(tmp.ToArray());
}

每个字符仅根据字典检查一次，如果在字典中找到则替换。

Answer 2

这个“技巧”怎么样？

string conv = Encoding.ASCII.GetString(Encoding.GetEncoding("Cyrillic").GetBytes(input));

Answer 3

没有正则表达式可能会更快。

    for( j = 0; j < i; j++ ) 
    {
        tmp = tmp.Replace(pats[j], repl[j]);
    }

编辑

使用Zip 和StringBuilder 的另一种方式：

StringBuilder result = new StringBuilder(input);
foreach (var zipped = patterns.Zip(replacements, (p, r) => new {p, r}))
{
  result = result.Replace(zipped.p, zipped.r);
}
return result.ToString();

Answer 4

首先，我会使用StringBuilder 在缓冲区内执行翻译，避免到处创建新字符串。

接下来，理想情况下，我们想要类似于XPath 的translate()，这样我们就可以使用字符串而不是数组或映射。让我们在extension method 中这样做：

public static StringBuilder Translate(this StringBuilder builder,
    string inChars, string outChars)
{
    int length = Math.Min(inChars.Length, outChars.Length);
    for (int i = 0; i < length; ++i) {
        builder.Replace(inChars[i], outChars[i]);
    }
    return builder;
}

然后使用它：

StringBuilder builder = new StringBuilder(yourString);
yourString = builder.Translate("åÅæÆäÄöÖøØèÈàÀìÌõÕïÏ",
    "aAaAaAoOoOeEaAiIoOiI").ToString();

Answer 5

原始正则表达式的问题在于您没有充分利用它。请记住，正则表达式模式可以有交替。您仍然需要一本字典，但您可以一次性完成，而无需遍历每个字符。

这将实现如下：

string[] pats = { "å", "Å", "æ", "Æ", "ä", "Ä", "ö", "Ö", "ø", "Ø" ,"è", "È", "à", "À", "ì", "Ì", "õ", "Õ", "ï", "Ï" };
string[] repl = { "a", "A", "a", "A", "a", "A", "o", "O", "o", "O", "e", "E", "a", "A", "i", "I", "o", "O", "i", "I" };
// using Zip as a shortcut, otherwise setup dictionary differently as others have shown
var dict = pats.Zip(repl, (k,v) => new { Key = k, Value = v }).ToDictionary(o => o.Key, o => o.Value);

string input = "åÅæÆäÄöÖøØèÈàÀìÌõÕïÏ";
string pattern = String.Join("|", dict.Keys.Select(k => k)); // use ToArray() for .NET 3.5
string result = Regex.Replace(input, pattern, m => dict[m.Value]);

Console.WriteLine("Pattern: " + pattern);
Console.WriteLine("Input: " + input);
Console.WriteLine("Result: " + result);

当然，您应该始终使用Regex.Escape 转义您的模式。在这种情况下，这不是必需的，因为我们知道有限的字符集并且不需要对它们进行转义。

Answer 6

如果您想删除重音，那么这个解决方案可能会有所帮助How do I remove diacritics (accents) from a string in .NET?

否则我会一次性完成：

Dictionary<char, char> replacements = new Dictionary<char, char>();
...
StringBuilder result = new StringBuilder();
foreach(char c in str)
{
  char rc;
  if (!_replacements.TryGetValue(c, out rc)
  {
    rc = c;
  }
  result.Append(rc);
}

Answer 7

在一对一字符替换的特殊情况下，最快的（恕我直言）方式（甚至与字典相比）将是一个完整的字符映射：

public class Converter
{
    private readonly char[] _map;

    public Converter()
    {
        // This code assumes char to be a short unsigned integer
        _map = new char[char.MaxValue];

        for (int i = 0; i < _map.Length; i++)
            _map[i] = (char)i;

        _map['å'] = 'a';  // Note that 'å' is used as an integer index into the array.
        _map['Å'] = 'A';
        _map['æ'] = 'a';
        // ... the rest of overriding map
    }

    public string Convert(string source)
    {
        if (string.IsNullOrEmpty(source))
            return source;

        var result = new char[source.Length];

        for (int i = 0; i < source.Length; i++)
            result[i] = _map[source[i]]; // convert using the map

        return new string(result);
    }
}

要进一步加快此代码的速度，您可能需要使用“不安全”关键字并使用指针。这样，可以更快地遍历字符串数组并且无需边界检查（理论上这会被 VM 优化掉，但可能不会）。

Answer 8

我不熟悉 Regex 类，但大多数正则表达式引擎都有一个音译操作，在这里可以很好地工作。那么您每条线路只需要一个呼叫。