是否可以改进此正则表达式以在 Excel 单元格中查找编号的文本行以避免错误匹配？

Question

I have a large spreadsheet where some cells may contain many lines of text, some numbered, some not. My goal is to extract these individual numbered 'items' into separate cells.

For example, an input cell might contain something like this (in between the "s):

"1. Party A complete.
2./3. Party B to construct as per drawing 805/12.
Use ITP 675/24.

4.Party C to be engaged."

Note that an item number starts at the beginning of a line or follows one like this using a "/". Numbers are always followed by a "." (dot). There may be some or no spaces following the dot and the text for an item may then be spread over multiple lines.

Operating on the above input cell, the desired output would be:

Cell 1: "1. Party A complete."
Cell 2: "2. Party B to construct as per drawing 805/12.
Use ITP 675/24."
Cell 3: "3. Party B to construct as per drawing 805/12.
Use ITP 675/24."
Cell 4: "4.Party C to be engaged."

I have been using the RegExp class object in VBA as follows. This allows me to pinpoint the start of items and then extract the text in between these points (or end of string):

Dim RegExObj1 As RegExp
Dim mc1 As MatchCollection

Set RegExObj1 = New RegExp

With RegExObj1
    .Global = True
    .IgnoreCase = True
    .MultiLine = True
    .Pattern = "(^|/)(\d+)\."
End With

Set mc1 = RegExObj1.Execute(CleanedCellText)

This generally works, but I get unwanted matches like "/12." and "/24.", from the ends of lines. How can I change the regex to exclude these?

Note that I capture the occurrence of "/" to determine if an item number needs to inherit the text from the next number up. In this case item 2 inherits the text from item 3. But I'm not sure if there is a better way to manage this challenge.

Answer 1

Given your data, a pattern like (?:\d+\.\/)|(?:\d+\.[\s\S]+?(?=(?:\x0A+\d+\.)|$)) will collect both the start of each line (numbered segment), and the rest of the line (numbered segment).

If a line number is followed by ./ , it collects only that so you can tell if you need to fill up by testing if the rightmost character is a / . After we populate the results array, we loop through it from bottom to top and decide where we need to fill in the blanks.

So here is another approach, using regex. As written, the formula returns a vertical array. If you have O365 with dynamic arrays, it will Spill the results. If you don't, you can retrieve them either by entering the formula as an array formula over multiple cells, or using the Index function

Option Explicit
Function foo(s) As String()
    Dim RE As RegExp, MC As MatchCollection, M As Match
    Const sPat As String = "(?:\d+\.\/)|(?:\d+\.[\s\S]+?(?=(?:\x0A+\d+\.)|$))"
    Dim sTemp() As String, I As Long
    
Set RE = New RegExp
With RE
    .Global = True
    .MultiLine = False
    .Pattern = sPat
    If .Test(s) = True Then
        Set MC = .Execute(s)
        ReDim sTemp(1 To MC.Count, 1 To 1) '2D array for vertical results
        I = 0
        For Each M In MC
            I = I + 1
            sTemp(I, 1) = M
        Next M
    End If
    
    For I = UBound(sTemp, 1) - 1 To LBound(sTemp, 1) Step -1
        If Right(sTemp(I, 1), 1) = "/" Then
            sTemp(I, 1) = Replace(sTemp(I, 1), "/", "") & Mid(sTemp(I + 1, 1), InStr(sTemp(I + 1, 1), ".") + 1, 999)
        End If
    Next I
        
    foo = sTemp
    
End With
    
End Function

Regex Explanation

Extract Lines

(?:\d+\.\/)|(?:\d+\.[\s\S]+?(?=(?:\x0A+\d+\.)|$))

Options: ^$ don't match at line breaks

• Match this alternative (?:\d+\.\/)
  • Match the regular expression below (?:\d+\.\/)
    • Match a single character that is a “digit” \d+
      • Between one and unlimited times, as many times as possible, giving back as needed (greedy) +
    • Match the character “.”literally \.
    • Match the character “/” literally \/
• Or match this alternative (?:\d+\.[\s\S]+?(?=(?:\x0A+\d+\.)|$))
  • Match the regular expression below (?:\d+\.[\s\S]+?(?=(?:\x0A+\d+\.)|$))
    • Match a single character that is a “digit” \d+
      • Between one and unlimited times, as many times as possible, giving back as needed (greedy) +
    • Match the character “.”literally \.
    • Match a single character present in the list below [\s\S]+?
      • Between one and unlimited times, as few times as possible, expanding as needed (lazy) +?
      • A “whitespace character” \s
      • Any character that is NOT a “whitespace character” \S
    • Assert that the regex below can be matched starting at this position (positive lookahead) (?=(?:\x0A+\d+\.)|$)
      • Match this alternative (?:\x0A+\d+\.)
        • Match the regular expression below (?:\x0A+\d+\.)
          • Match the line feed character \x0A+
            • Between one and unlimited times, as many times as possible, giving back as needed (greedy) +
          • Match a single character that is a “digit” \d+
            • Between one and unlimited times, as many times as possible, giving back as needed (greedy) +
          • Match the character “.”literally \.
      • Or match this alternative $
        • Assert position at the very end of the string $

Created with RegexBuddy