REGEX返回字符串中所有大写短语的列表

Question

Hi I've been fooling around with this for awhile figured it was time to ask for help ...

I'm trying to return all capital char (non numeric or special char phrases) sequences longer then 5 characters from a wacky a string.

so for:

02/02/12-02:45 PM(CKI)-DISC RSPNS SRVD 01/31/12-PRINTED DISCOVERY:spina.bp.doc(DGB)   
01/27/12-ON CAL-FILED NOTICE OF TRIAL(JCX) 01/24/12-SENT OUR DEMANDS(Auto-Gen) 01/23/12-
02:31  PM-File pulled and given to KG for responses.(JLS) 01/20/12(PC)-rcd df jmt af

I would want to return a list of

DISC RSPNS SRVD

PRINTED DISCOVERY

FILED NOTICE OF TRIAL

SENT OUR DEMANDS

I've been fooling around with variations of the following:

[A-Z][A-Z\d]+ 
[A-Z][A-Z\d]+ [A-Z][A-Z\d]+"

however this is a little outside my scope of knowledge with Regex.

Edit

I'm trying

string[] capWords = Regex.Split(d.caption, @"[A-Z\s]{5,}");
foreach (var u in capWords) { Console.WriteLine(u); }

Outputting:

02/02/12-02:45 PM(CKI)- 01/31/12-

:spina.bp.doc(DGB) 01/27/12-

(JCX) 01/24/12- (Auto-Gen) 01/23/12-02:31 PM-File pulled and given to KG for responses.(JLS) 01/20/12(PC)-rcd df jmt af

Kendall's Suggestion Outputs:

02/02/12-02:45 PM(CKI)- 01/31/12-

:spina.bp.doc(DGB) 01/27/12-

(JCX) 01/24/12- (Auto-Gen) 01/23/12-02:31 PM-File pulled and given to KG for responses.(JLS) 01/20/12(PC)-rcd df jmt af

Answer 1

Here you go:

[AZ\\s]{5,}

Tested and returns only the items you listed.

Explanation:

[AZ\\s] - matches only capital letters and spaces

{5,} - matches must be at least 5 characters, with no upper limit on number of characters

Code:

MatchCollection matches = Regex.Matches(d.caption, @"[A-Z\s]{5,}");
foreach (Match match in matches)
{
    Console.WriteLine(match.Value);
}

Answer 2

Try this. I am assuming you want leading/trailing spaces stripped.

[A-Z][A-Z ]{4,}[A-Z]

Also, I don't think you want Regex.Split.

var matches = Regex.Matches(d.caption, @"[A-Z][A-Z ]{4,}[A-Z]");
foreach (var match in matches)
{
    Console.WriteLine(match.Value);
}

You could also do:

var matches = Regex.Matches(d.caption, @"[A-Z][A-Z ]{4,}[A-Z]")
                   .OfType<Match>()
                   .Select(m => m.Value);
foreach (string match in matches)
{
    Console.WriteLine(match);
}

Answer 3

You had asked for a single RegEx solution but using given criteria and examples I could not get a single reg ex to count a string and ignore a certain character type (spaces). Failure was on character groups like ON CAL which should fail as a match but were passing because of the total character count.

So in order to make sure that character groups with only 5 Uppercase characters were present I had to use two regEx expressions. This was a little cumbersome and I was able to do this faster and much simpler with string methods.

This might work with a single regEx if you could list some certainties about the formatting of the source text. For example if we knew that the character groups that you are looking for are always preceded by a dash and terminated by a punctuation mark that is not a dash, or terminated by a number.

5 PM( --- FAIL (not preceded by a dash)

(CKI) --- FAIL (not preceded by a dash)

-DISC RSPNS SRVD 0 --- PASS

-PRINTED DISCOVERY: --- PASS

-ON CAL- --- FAIL (terminated by a dash)

-FILED NOTICE OF TRIAL( --- PASS

-SENT OUR DEMANDS( --- PASS

Barring that, I have included the code that will get you your results in one of two ways. I prefer the second.

        String source1 = "02/02/12-02:45 PM(CKI)-DISC RSPNS SRVD 01/31/12-PRINTED
 DISCOVERY:spina.bp.doc(DGB) 01/27/12-ON CAL-FILED NOTICE OF TRIAL(JCX) 01/24/12-SENT
 OUR DEMANDS(Auto-Gen) 01/23/12- 02:31 PM-File pulled and given to KG for responses.(JLS) 01/20/12(PC)-rcd df jmt af ";

    String assembledString;

    public void bumbleBeeTunaTest()
    {
        String strippedString = source1.Replace(" ", "");

        String regString1 = ""; 
        String regString2 = @"([A-Z]{6,})";
        String matchHold1,matchHold1First,matchHold1Last,matchHold1Middle;
        Int32 matchHold1Len;


        Regex regExTwo = new Regex(regString2);

        MatchCollection regMatch2 = regExTwo.Matches(strippedString);


        foreach (Match match2 in regMatch2)
        {
            matchHold1 = match2.Groups[1].Value;
            matchHold1Len = matchHold1.Length;
            matchHold1First = matchHold1.Substring(0,1);
            matchHold1Last = matchHold1.Substring(matchHold1Len - 1,1);
            matchHold1Middle = matchHold1.Substring(1, matchHold1Len - 2);


            Debug.Print("Stripped String Matches - " + matchHold1);


            regString1 = @"(" + matchHold1First + "[" + matchHold1Middle+  " ]{" + (matchHold1Len -1) + ",}" + matchHold1Last + ")";

            Regex regExOne = new Regex(regString1);

            MatchCollection regMatch1 = regExOne.Matches(source1);

            regMatch1 = regExOne.Matches(source1);



            foreach (Match match1 in regMatch1)
            {

                Debug.Print("Re-Assembled Matches :" + match1.Groups[1].Value.ToString());
            }

        }

        // Does the same thing as the above.  Just a little simpler.
        for (int i = 0; i < source1.Length; i++)
        {
            if (char.IsUpper(source1[i]) | char.IsWhiteSpace(source1[i]))
            {
                assembledString += source1[i];
            }
            else
            {
                if (!string.IsNullOrEmpty(assembledString))
                {
                    if (assembledString.Count(char.IsUpper) > 5)
                    {
                        Debug.Print("Non Reg Ex Version "  + assembledString);
                    }
                    assembledString = "";
                }
            }
        }
    }

The output looks like this.

Stripped String Matches - DISCRSPNSSRVD
Re-Assembled Matches :DISC RSPNS SRVD
Stripped String Matches - PRINTEDDISCOVERY
Re-Assembled Matches :PRINTED DISCOVERY
Stripped String Matches - FILEDNOTICEOFTRIAL
Re-Assembled Matches :FILED NOTICE OF TRIAL
Stripped String Matches - SENTOURDEMANDS
Re-Assembled Matches :SENT OUR DEMANDS
Non Reg Ex Version DISC RSPNS SRVD 
Non Reg Ex Version PRINTED DISCOVERY
Non Reg Ex Version FILED NOTICE OF TRIAL
Non Reg Ex Version SENT OUR DEMANDS