Delen via

Reguliere expressies (C++/CLI)

Demonstreert verschillende tekenreeksbewerkingen met behulp van reguliere expressieklassen in .NET Framework.

In de volgende onderwerpen wordt het gebruik van de .NET Framework-naamruimte System.Text.RegularExpressions (en in één geval de System.String.Split methode) gedemonstreerde om tekenreeksen te zoeken, te parseren en te wijzigen.

Tekenreeksen parseren met reguliere expressies

In het volgende codevoorbeeld ziet u eenvoudige tekenreeksparsering met behulp van de Regex klasse in de System.Text.RegularExpressions naamruimte. Een tekenreeks met meerdere typen scheidingstekens wordt samengesteld. De tekenreeks wordt vervolgens geparseerd met behulp van de Regex klasse in combinatie met de Match klasse. Vervolgens wordt elk woord in de zin afzonderlijk weergegeven.

Voorbeeld

// regex_parse.cpp
// compile with: /clr
#using <system.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main( )
{
   int words = 0;
   String^ pattern = "[a-zA-Z]*";
   Console::WriteLine( "pattern : '{0}'", pattern );
   Regex^ regex = gcnew Regex( pattern );

   String^ line = "one\ttwo three:four,five six  seven";
   Console::WriteLine( "text : '{0}'", line );
   for( Match^ match = regex->Match( line );
        match->Success; match = match->NextMatch( ) )
   {
      if( match->Value->Length > 0 )
      {
         words++;
         Console::WriteLine( "{0}", match->Value );
      }
   }
   Console::WriteLine( "Number of Words : {0}", words );

   return 0;
}

Reeksen parseren met behulp van de Split-methode

In het volgende codevoorbeeld ziet u hoe u de System.String.Split methode gebruikt om elk woord uit een tekenreeks te extraheren. Een tekenreeks met verschillende soorten woordscheiders wordt samengesteld en vervolgens geparseerd door Split aan te roepen met een lijst van de scheiders. Vervolgens wordt elk woord in de zin afzonderlijk weergegeven.

Voorbeeld

// regex_split.cpp
// compile with: /clr
using namespace System;

int main()
{
   String^ delimStr = " ,.:\t";
   Console::WriteLine( "delimiter : '{0}'", delimStr );
   array<Char>^ delimiter = delimStr->ToCharArray( );
   array<String^>^ words;
   String^ line = "one\ttwo three:four,five six seven";

   Console::WriteLine( "text : '{0}'", line );
   words = line->Split( delimiter );
   Console::WriteLine( "Number of Words : {0}", words->Length );
   for (int word=0; word<words->Length; word++)
      Console::WriteLine( "{0}", words[word] );

   return 0;
}

Reguliere expressies gebruiken voor eenvoudige overeenkomsten

In het volgende codevoorbeeld worden reguliere expressies gebruikt om exacte subtekenreeksovereenkomsten te zoeken. De zoekopdracht wordt uitgevoerd door de statische IsMatch methode, waarbij twee tekenreeksen als invoer worden gebruikt. De eerste is de tekenreeks die moet worden doorzocht en het tweede is het patroon dat moet worden gezocht.

Voorbeeld

// regex_simple.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main()
{
   array<String^>^ sentence =
   {
      "cow over the moon",
      "Betsy the Cow",
      "cowering in the corner",
      "no match here"
   };

   String^ matchStr = "cow";
   for (int i=0; i<sentence->Length; i++)
   {
      Console::Write( "{0,24}", sentence[i] );
      if ( Regex::IsMatch( sentence[i], matchStr,
                     RegexOptions::IgnoreCase ) )
         Console::WriteLine("  (match for '{0}' found)", matchStr);
      else
         Console::WriteLine("");
   }
   return 0;
}

Reguliere expressies gebruiken om gegevensvelden te extraheren

In het volgende codevoorbeeld wordt het gebruik van reguliere expressies gedemonstreerd om gegevens uit een opgemaakte tekenreeks te extraheren. In het volgende codevoorbeeld wordt de Regex klasse gebruikt om een patroon op te geven dat overeenkomt met een e-mailadres. Deze patter bevat veld-id's die kunnen worden gebruikt om de gebruikers- en hostnaamgedeelten van elk e-mailadres op te halen. De Match klasse wordt gebruikt om de werkelijke patroonkoppeling uit te voeren. Als het opgegeven e-mailadres geldig is, worden de gebruikersnaam en hostnamen geëxtraheerd en weergegeven.

Voorbeeld

// Regex_extract.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main()
{
    array<String^>^ address=
    {
        "jay@southridgevideo.com",
        "barry@adatum.com",
        "treyresearch.net",
        "karen@proseware.com"
    };

    Regex^ emailregex = gcnew Regex("(?<user>[^@]+)@(?<host>.+)");

    for (int i=0; i<address->Length; i++)
    {
        Match^ m = emailregex->Match( address[i] );
        Console::Write("\n{0,25}", address[i]);

        if ( m->Success )
        {
            Console::Write("   User='{0}'",
            m->Groups["user"]->Value);
            Console::Write("   Host='{0}'",
            m->Groups["host"]->Value);
        }
        else
            Console::Write("   (invalid email address)");
        }

    Console::WriteLine("");
    return 0;
}

Reguliere expressies gebruiken om gegevens opnieuw te rangschikken

In het volgende codevoorbeeld ziet u hoe de reguliere expressieondersteuning van .NET Framework kan worden gebruikt voor het opnieuw rangschiknen of opnieuw opmaken van gegevens. In het volgende codevoorbeeld worden de Regex en Match klassen gebruikt om voor- en achternamen uit een tekenreeks te extraheren en deze naamelementen vervolgens in omgekeerde volgorde weer te geven.

De Regex klasse wordt gebruikt om een reguliere expressie te maken die de huidige indeling van de gegevens beschrijft. De twee namen worden verondersteld te worden gescheiden door een komma en kunnen elke hoeveelheid witruimte rond de komma gebruiken. De Match methode wordt vervolgens gebruikt om elke tekenreeks te analyseren. Als dit lukt, worden voor- en achternamen opgehaald uit het Match object en weergegeven.

Voorbeeld

// regex_reorder.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace Text::RegularExpressions;

int main()
{
   array<String^>^ name =
   {
      "Abolrous, Sam",
      "Berg,Matt",
      "Berry , Jo",
      "www.contoso.com"
   };

   Regex^ reg = gcnew Regex("(?<last>\\w*)\\s*,\\s*(?<first>\\w*)");

   for ( int i=0; i < name->Length; i++ )
   {
      Console::Write( "{0,-20}", name[i] );
      Match^ m = reg->Match( name[i] );
      if ( m->Success )
      {
         String^ first = m->Groups["first"]->Value;
         String^ last = m->Groups["last"]->Value;
         Console::WriteLine("{0} {1}", first, last);
      }
      else
         Console::WriteLine("(invalid)");
   }
   return 0;
}

In het volgende codevoorbeeld ziet u hoe de reguliere expressieklasse Regex kan worden gebruikt om te zoeken en vervangen. Dit gebeurt met de Replace methode. De gebruikte versie heeft twee tekenreeksen als invoer: de tekenreeks die moet worden gewijzigd en de tekenreeks die moet worden ingevoegd in plaats van de secties (indien van toepassing) die overeenkomen met het patroon dat aan het Regex object is gegeven.

Deze code vervangt alle cijfers in een tekenreeks door onderstrepingstekens (_) en vervangt deze door een lege tekenreeks, waardoor ze effectief worden verwijderd. Hetzelfde effect kan in één stap worden bereikt, maar er worden hier twee stappen gebruikt voor demonstratiedoeleinden.

Voorbeeld

// regex_replace.cpp
// compile with: /clr
#using <System.dll>
using namespace System::Text::RegularExpressions;
using namespace System;

int main()
{
   String^ before = "The q43uick bro254wn f0ox ju4mped";
   Console::WriteLine("original  : {0}", before);

   Regex^ digitRegex = gcnew Regex("(?<digit>[0-9])");
   String^ after = digitRegex->Replace(before, "_");
   Console::WriteLine("1st regex : {0}", after);

   Regex^ underbarRegex = gcnew Regex("_");
   String^ after2 = underbarRegex->Replace(after, "");
   Console::WriteLine("2nd regex : {0}", after2);

   return 0;
}

Reguliere expressies gebruiken om gegevensopmaak te valideren

In het volgende codevoorbeeld ziet u hoe reguliere expressies worden gebruikt om de opmaak van een tekenreeks te controleren. In het volgende codevoorbeeld moet de tekenreeks een geldig telefoonnummer bevatten. In het volgende codevoorbeeld wordt de tekenreeks \d{3}-\d{3}-\d{4} gebruikt om aan te geven dat elk veld een geldig telefoonnummer vertegenwoordigt. De 'd' in de tekenreeks geeft een cijfer aan en het argument na elke 'd' geeft het aantal cijfers aan dat aanwezig moet zijn. In dit geval moet het getal worden gescheiden door streepjes.

Voorbeeld

// regex_validate.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace Text::RegularExpressions;

int main()
{
   array<String^>^ number =
   {
      "123-456-7890",
      "444-234-22450",
      "690-203-6578",
      "146-893-232",
      "146-839-2322",
      "4007-295-1111",
      "407-295-1111",
      "407-2-5555",
   };

   String^ regStr = "^\\d{3}-\\d{3}-\\d{4}$";

   for ( int i = 0; i < number->Length; i++ )
   {
      Console::Write( "{0,14}", number[i] );

      if ( Regex::IsMatch( number[i], regStr ) )
         Console::WriteLine(" - valid");
      else
         Console::WriteLine(" - invalid");
   }
   return 0;
}

Reguliere .NET Framework-expressies

Zie ook

.NET-programmering met C++/CLI (Visual C++)

  • Last updated on