Megosztás a következőn keresztül:

.NET reguláris kifejezések

A reguláris kifejezések hatékony, rugalmas és hatékony módszert biztosítanak a szöveg feldolgozására. A reguláris kifejezések széles mintaegyeztetési jelölése lehetővé teszi nagy mennyiségű szöveg gyors elemzését a következőre:

  • Adott karakterminták keresése.
  • Ellenőrizze, hogy a szöveg megfelel-e egy előre definiált mintának (például egy e-mail-címnek).
  • Szövegrészek kinyerése, szerkesztése, cseréje vagy törlése.
  • Tegye a kinyert karakterláncokat egy gyűjteménybe a jelentés létrehozásához.

Számos olyan alkalmazás esetében, amely sztringekkel foglalkozik, vagy amelyek nagy szövegblokkokat elemeznek, a reguláris kifejezések elengedhetetlenek.

A reguláris kifejezések működése

A normál kifejezésekkel történő szövegfeldolgozás középpontjában a reguláris kifejezésmotor áll, amelyet a .NET System.Text.RegularExpressions.Regex objektuma jelöl. A reguláris kifejezések használatával végzett szövegfeldolgozáshoz legalább a normál kifejezésmotornak a következő két információelemre van szüksége:

  • A szövegben azonosítható reguláris kifejezésminta.

    A .NET-ben a reguláris kifejezésmintákat egy speciális szintaxis vagy nyelv határozza meg, amely kompatibilis a Perl 5 reguláris kifejezéseivel, és hozzáad néhány további funkciót, például a jobbról balra való egyeztetést. További információ: Regular Expression Language – Quick Reference.

  • A normál kifejezésmintához elemezni kívánt szöveg.

A Regex osztály módszereivel a következő műveleteket hajthatja végre:

A reguláris kifejezésobjektum-modell áttekintését a A reguláris kifejezésobjektum-modellcímű cikkben tekintheti meg.

További információ a reguláris kifejezés nyelvéről: Regular Expression Language – Quick Reference, vagy töltse le és nyomtassa ki az alábbi brosúrák egyikét:

Reguláris kifejezési példák

A String osztály sztringkeresési és cseremetszeteket tartalmaz, amelyeket akkor használhat, ha nagyobb sztringben szeretne literális sztringeket keresni. A reguláris kifejezések akkor hasznosak leginkább, ha egy nagyobb sztringben több részsztring egyikét szeretné megtalálni, vagy ha egy sztring mintáit szeretné azonosítani, ahogy az alábbi példák is szemléltetik.

Figyelmeztetés

Ha System.Text.RegularExpressions használ a nem megbízható bemenetek feldolgozásához, adjon meg időtúllépést. Egy rosszindulatú felhasználó bemenetet adhat a RegularExpressions-hoz, ami szolgáltatásmegtagadási támadást okoz. ASP.NET Core keretrendszer API-k, amelyek RegularExpressions időtúllépést használnak.

Tipp

A System.Web.RegularExpressions névtér számos reguláris kifejezésobjektumot tartalmaz, amelyek előre definiált reguláris kifejezésmintákat implementálnak a HTML-, XML- és ASP.NET-dokumentumok sztringjeinek elemzéséhez. A TagRegex osztály például azonosítja a kezdőcímkéket egy sztringben, a CommentRegex osztály pedig ASP.NET megjegyzéseket azonosít egy sztringben.

1. példa: Szövegrészek cseréje

Tegyük fel, hogy egy levelezőlista olyan neveket tartalmaz, amelyek néha egy címet (Mr., Mrs., Miss vagy Ms.) és egy vezeték- és utónevet tartalmaznak. Tegyük fel, hogy nem szeretné belefoglalni a címeket, amikor borítékcímkéket hoz létre a listából. Ebben az esetben egy reguláris kifejezéssel eltávolíthatja a címeket, ahogy az alábbi példa is szemlélteti:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(Mr\\.? |Mrs\\.? |Miss |Ms\\.? )";
      string[] names = { "Mr. Henry Hunt", "Ms. Sara Samuels",
                         "Abraham Adams", "Ms. Nicole Norris" };
      foreach (string name in names)
         Console.WriteLine(Regex.Replace(name, pattern, String.Empty));
   }
}
// The example displays the following output:
//    Henry Hunt
//    Sara Samuels
//    Abraham Adams
//    Nicole Norris

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(Mr\.? |Mrs\.? |Miss |Ms\.? )"
        Dim names() As String = {"Mr. Henry Hunt", "Ms. Sara Samuels", _
                                  "Abraham Adams", "Ms. Nicole Norris"}
        For Each name As String In names
            Console.WriteLine(Regex.Replace(name, pattern, String.Empty))
        Next
    End Sub
End Module
' The example displays the following output:
'    Henry Hunt
'    Sara Samuels
'    Abraham Adams
'    Nicole Norris

A reguláris kifejezésminta (Mr\.? |Mrs\.? |Miss |Ms\.? ) megegyezik a "Mr ", "Mr. ", "Mrs ", "Mrs. ", "Miss ", "Ms ", vagy "Ms. " előfordulásával. A Regex.Replace metódus hívása a megfeleltetett karakterláncot String.Empty-re cseréli; más szóval eltávolítja az eredeti karakterláncból.

2. példa: Ismétlődő szavak azonosítása

A szavak véletlen duplikálása gyakori hiba, amelyet az írók okoznak. Használjon reguláris kifejezést a duplikált szavak azonosításához, ahogyan az alábbi példa is mutatja:

using System;
using System.Text.RegularExpressions;

public class Class1
{
   public static void Main()
   {
      string pattern = @"\b(\w+?)\s\1\b";
      string input = "This this is a nice day. What about this? This tastes good. I saw a a dog.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine($"{match.Value} (duplicates '{match.Groups[1].Value}') at position {match.Index}");
   }
}
// The example displays the following output:
//       This this (duplicates 'This') at position 0
//       a a (duplicates 'a') at position 66

Imports System.Text.RegularExpressions

Module modMain
    Public Sub Main()
        Dim pattern As String = "\b(\w+?)\s\1\b"
        Dim input As String = "This this is a nice day. What about this? This tastes good. I saw a a dog."
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
            Console.WriteLine("{0} (duplicates '{1}') at position {2}", _
                              match.Value, match.Groups(1).Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       This this (duplicates 'This') at position 0
'       a a (duplicates 'a') at position 66

A reguláris kifejezésminta \b(\w+?)\s\1\b a következőképpen értelmezhető:

Minta Értelmezés
\b Kezdjen szóhatáron.
(\w+?) Egy vagy több szó karakterének megfeleltetése, azonban a lehető legkevesebb karakterből. Együtt alkotnak egy csoportot, amely \1néven is nevezhető.
\s Egyezz meg egy szóköz karakterrel.
\1 Egyeztesse a részkarakterláncot a \1nevű csoporttal.
\b Egy szóhatár egyeztetése.

A Regex.Matches metódust a reguláris kifejezés opcióival hívják meg, amelyek RegexOptions.IgnoreCase-re vannak állítva. Ezért az egyezési művelet nem érzékeny a kis- és nagybetűkre, és a példa a "This this" alsztringet duplikációként azonosítja.

A bemeneti sztring tartalmazza a "this" részsztringet? Ez. A beavatkozó írásjel miatt azonban a rendszer nem azonosítja duplikációként.

3. példa: Kultúraérzékeny reguláris kifejezés dinamikus létrehozása

Az alábbi példa szemlélteti a reguláris kifejezések erejét, amelyet a .NET globalizációs képességei által nyújtott rugalmasság egészít ki. A NumberFormatInfo objektummal határozza meg a rendszer jelenlegi kultúrájában lévő pénznemértékek formátumát. Ezután ezeket az információkat felhasználva dinamikusan létrehoz egy reguláris kifejezést, amely pénznemértékeket nyer ki a szövegből. Minden egyezéshez kinyeri azt az alcsoportot, amely csak a numerikus sztringet tartalmazza, átalakítja Decimal értékké, és kiszámítja a futó végösszeget.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Define text to be parsed.
      string input = "Office expenses on 2/13/2008:\n" +
                     "Paper (500 sheets)                      $3.95\n" +
                     "Pencils (box of 10)                     $1.00\n" +
                     "Pens (box of 10)                        $4.49\n" +
                     "Erasers                                 $2.19\n" +
                     "Ink jet printer                        $69.95\n\n" +
                     "Total Expenses                        $ 81.58\n";

      // Get current culture's NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
      // Assign needed property values to variables.
      string currencySymbol = nfi.CurrencySymbol;
      bool symbolPrecedesIfPositive = nfi.CurrencyPositivePattern % 2 == 0;
      string groupSeparator = nfi.CurrencyGroupSeparator;
      string decimalSeparator = nfi.CurrencyDecimalSeparator;

      // Form regular expression pattern.
      string pattern = Regex.Escape( symbolPrecedesIfPositive ? currencySymbol : "") +
                       @"\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" +
                       Regex.Escape(decimalSeparator) + "[0-9]+)?)" +
                       (! symbolPrecedesIfPositive ? currencySymbol : "");
      Console.WriteLine( "The regular expression pattern is:");
      Console.WriteLine("   " + pattern);

      // Get text that matches regular expression pattern.
      MatchCollection matches = Regex.Matches(input, pattern,
                                              RegexOptions.IgnorePatternWhitespace);
      Console.WriteLine($"Found {matches.Count} matches.");

      // Get numeric string, convert it to a value, and add it to List object.
      List<decimal> expenses = new List<Decimal>();

      foreach (Match match in matches)
         expenses.Add(Decimal.Parse(match.Groups[1].Value));

      // Determine whether total is present and if present, whether it is correct.
      decimal total = 0;
      foreach (decimal value in expenses)
         total += value;

      if (total / 2 == expenses[expenses.Count - 1])
         Console.WriteLine($"The expenses total {expenses[expenses.Count - 1]:C2}.");
      else
         Console.WriteLine($"The expenses total {total:C2}.");
   }
}
// The example displays the following output:
//       The regular expression pattern is:
//          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
//       Found 6 matches.
//       The expenses total $81.58.

Imports System.Collections.Generic
Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
    Public Sub Main()
        ' Define text to be parsed.
        Dim input As String = "Office expenses on 2/13/2008:" + vbCrLf + _
                              "Paper (500 sheets)                      $3.95" + vbCrLf + _
                              "Pencils (box of 10)                     $1.00" + vbCrLf + _
                              "Pens (box of 10)                        $4.49" + vbCrLf + _
                              "Erasers                                 $2.19" + vbCrLf + _
                              "Ink jet printer                        $69.95" + vbCrLf + vbCrLf + _
                              "Total Expenses                        $ 81.58" + vbCrLf
        ' Get current culture's NumberFormatInfo object.
        Dim nfi As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
        ' Assign needed property values to variables.
        Dim currencySymbol As String = nfi.CurrencySymbol
        Dim symbolPrecedesIfPositive As Boolean = CBool(nfi.CurrencyPositivePattern Mod 2 = 0)
        Dim groupSeparator As String = nfi.CurrencyGroupSeparator
        Dim decimalSeparator As String = nfi.CurrencyDecimalSeparator

        ' Form regular expression pattern.
        Dim pattern As String = Regex.Escape(CStr(IIf(symbolPrecedesIfPositive, currencySymbol, ""))) + _
                                "\s*[-+]?" + "([0-9]{0,3}(" + groupSeparator + "[0-9]{3})*(" + _
                                Regex.Escape(decimalSeparator) + "[0-9]+)?)" + _
                                CStr(IIf(Not symbolPrecedesIfPositive, currencySymbol, ""))
        Console.WriteLine("The regular expression pattern is: ")
        Console.WriteLine("   " + pattern)

        ' Get text that matches regular expression pattern.
        Dim matches As MatchCollection = Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
        Console.WriteLine("Found {0} matches. ", matches.Count)

        ' Get numeric string, convert it to a value, and add it to List object.
        Dim expenses As New List(Of Decimal)

        For Each match As Match In matches
            expenses.Add(Decimal.Parse(match.Groups.Item(1).Value))
        Next

        ' Determine whether total is present and if present, whether it is correct.
        Dim total As Decimal
        For Each value As Decimal In expenses
            total += value
        Next

        If total / 2 = expenses(expenses.Count - 1) Then
            Console.WriteLine("The expenses total {0:C2}.", expenses(expenses.Count - 1))
        Else
            Console.WriteLine("The expenses total {0:C2}.", total)
        End If
    End Sub
End Module
' The example displays the following output:
'       The regular expression pattern is:
'          \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?)
'       Found 6 matches.
'       The expenses total $81.58.

Azon a számítógépen, amelynek jelenlegi kultúrája angol – Egyesült Államok (en-US), a példa dinamikusan építi ki a reguláris kifejezést \$\s*[-+]?([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?). Ez a reguláris kifejezésminta a következőképpen értelmezhető:

Minta Értelmezés
\$ Keresse meg a dollár szimbólum ($) egyetlen előfordulását a bemeneti sztringben. A reguláris kifejezésminta sztringje egy fordított perjelet tartalmaz, amely azt jelzi, hogy a dollár szimbólumot szó szerint kell értelmezni, nem pedig reguláris kifejezéshorgonyként. A $ szimbólum önmagában azt jelzi, hogy a reguláris kifejezésmotornak a karakterlánc végén kell megpróbálnia megkezdeni az egyezést. Annak érdekében, hogy a jelenlegi kultúra pénznemszimbóluma ne legyen tévesen értelmezve normál kifejezésszimbólumként, a példa meghívja a Regex.Escape metódust, hogy elkerülje a karaktert.
\s* Keressen nulla vagy több előfordulást a fehér karakterek között.
[-+]? Keressen nulla vagy egy pozitív vagy negatív előjel előfordulását.
([0-9]{0,3}(,[0-9]{3})*(\.[0-9]+)?) A külső zárójelek rögzítési csoportként vagy alkifejezésként határozzák meg ezt a kifejezést. Ha talál egyezést, az egyező sztring ezen részével kapcsolatos információk a Group tulajdonság által visszaadott GroupCollection objektum második Match.Groups objektumából kérhetők le. A gyűjtemény első eleme a teljes megfeleltetést jelöli.
[0-9]{0,3} Keresse meg a 0–9 tizedesjegy nullától háromig való előfordulását.
(,[0-9]{3})* Keresse meg a csoportelválasztó nulla vagy több előfordulását, amelyet három tizedesjegy követ.
\. Keresse meg a decimális elválasztó egyetlen előfordulását.
[0-9]+ Keressen egy vagy több számjegyet.
(\.[0-9]+)? Keresse meg a decimális elválasztó nulla vagy egy előfordulását, amelyet legalább egy tizedesjegy követ.

Ha a bemeneti sztringben minden alpatter megtalálható, az egyezés sikeres lesz, és a Match objektumhoz hozzáad egy MatchCollection objektumot, amely információkat tartalmaz az egyezésről.

Cím Leírás
Reguláris kifejezés nyelve – rövid útmutató A szokásos kifejezések definiálásához használható karakterekről, operátorokról és szerkezetekről nyújt információt.
Reguláris kifejezésobjektum-modell Olyan információkat és kód példákat tartalmaz, amelyek bemutatják a reguláris kifejezésosztályok használatát.
Reguláris kifejezés viselkedésének részletei A .NET-reguláris kifejezések képességeiről és viselkedéséről nyújt tájékoztatást.
Reguláris kifejezések használata a Visual Studio

Referenciák