将字符串拆分为单词并与其他数据重新连接

Question

我有一个使用Regex 在文本string 中查找模式的方法。它有效，但还不够，因为它要求文本以确切的顺序出现，而不是将短语视为一组单词。

    public static string HighlightExceptV1(this string text, string wordsToExclude)
    {
        // Original version
        // wordsToExclude usually consists of a 1, 2 or 3 word term.
        // The text must be in a specific order to work.

        var pattern = $@"(\s*\b{wordsToExclude}\b\s*)";

        // Do something to string...
    }

这个版本在前一个版本的基础上进行了改进，它确实允许以任何顺序匹配单词，但是它在最终输出中导致一些间距问题，因为间距被删除并替换为管道。

    public static string HighlightExceptV2(this string text, string wordsToExclude)
    {
        // This version allows the words to be matched in any order, but it has
        // flaws, in that the natural spacing is removed in some cases.
        var words = wordsToExclude.Replace(' ', '|');

        var pattern = $@"(\s*\b{words}\b\s*)";

        // Example phase: big blue widget
        // Example output: $@"(\s*\bbig|blue|widget\b\s*)"

        // Do something to string...
    }

理想情况下，需要在每个单词周围保留间距。下面的伪示例显示了我正在尝试做的事情。

1. 将原始短语拆分为单词
2. 将每个单词包装在一个正则表达式模式中，以保留空格 匹配时

3. 重新加入单词模式以生成将用于 匹配

   public static string HighlightExceptV3(this string text, string wordsToExclude)
   {
       // The outputted pattern must be dynamic due to unknown
       // words in phrase.
   
       // Example phrase: big blue widgets
   
       var words = wordsToExclude.Replace(' ', '|');
       // Example: big|blue|widget
   
       // The code below isn't complete - merely an example
       // of the required output.
   
       var wordPattern = $@"\s*\b{word}\b\s*";
       // Example: $@"\s*\bwidget\b\s*"
   
       var phrasePattern = "$({rejoinedArray})";
       // @"(\s*\bbig\b\s*|\s*\bblue\b\s*|\s*\bwidget\b\s*)";
   
       // Do something to string...
   }
   

注意：处理单词边界间距可能有更好的方法，但我不是正则表达式专家。

我正在寻找一些帮助/建议来获取拆分数组，将其包装，然后以最简洁的方式重新加入。

Answer 1

您需要将所有备选方案包含在一个非捕获组中，(?:...|...)。此外，为了进一步解决最终的问题，我建议用它们的环视明确等价物替换单词边界，(?<!\w)...(?!\w)。

这是working C# snippet：

var text = "there are big widgets in this phrase blue widgets too";
var words = "big blue widgets";
var pattern = $@"(\s*(?<!\w)(?:{string.Join("|", words.Split(' ').Select(Regex.Escape))})(?!\w)\s*)";
var result = string.Concat(Regex.Split(text, pattern, RegexOptions.IgnoreCase).Select((str, index) =>
            index % 2 == 0 && !string.IsNullOrWhiteSpace(str) ? $"<b>{str}</b>" : str));
 Console.WriteLine(result);

注意事项

• words.Split(' ').Select(Regex.Escape) - 用空格分割 words 文本并正则表达式转义每个项目
• string.Join("|",...) 重新构建在项目之间插入 | 的字符串
• (?<!\w)negative lookbehind 匹配一个没有紧跟在单词 char 前面的位置，(?!\w)negative lookahead 匹配一个没有紧跟单词 char 的位置。

Answer 2

我建议使用2 状态（输入和输出选择）和Regex.Replace（我们可以保持原样 - word 或替换它）来实现 FSM（有限状态机）与<b>word、word<\b> 或<b>word<\b>)

private static string MyModify(string text, string wordsToExclude) {
  HashSet<string> exclude = new HashSet<string>(
    wordsToExclude.Split(' '), StringComparer.OrdinalIgnoreCase);

  bool inSelection = false;

  string result = Regex.Replace(text, @"[\w']+", match => {
      var next = match.NextMatch();

      if (inSelection) {
        if (next.Success && exclude.Contains(next.Value)) {
          inSelection = false;

          return match.Value + "</b>";
        }
        else
          return match.Value;
      }
      else {
        if (exclude.Contains(match.Value))
          return match.Value;
        else if (next.Success && exclude.Contains(next.Value))
          return "<b>" + match.Value + "</b>";
        else {
          inSelection = true;
          return "<b>" + match.Value;
        }
      }
    });

  if (inSelection)
    result += "</b>";

  return result;
}

演示：

string wordsToExclude = "big widgets blue if";

string[] tests = new string[] {
  "widgets for big blue",
  "big widgets are great but better if blue",
  "blue",
  "great but expensive",
  "big and small, blue and green",
};

string report = string.Join(Environment.NewLine, tests
  .Select(test => $"{test,-40} -> {MyModify(test, wordsToExclude)}"));

Console.Write(report);

结果：

widgets for big blue                     -> widgets <b>for</b> big blue
big widgets are great but better if blue -> big widgets <b>are great but better</b> if blue
blue                                     -> blue
great but expensive                      -> <b>great but expensive</b>
big and small, blue and green            -> big <b>and small</b>, blue <b>and green</b>