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

.NET reguláris kifejezések

  • Cikk

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:

  • Konkrét 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.
  • Kinyert sztringek hozzáadása egy gyűjteményhez 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 reguláris kifejezésekkel történő szövegfeldolgozás középpontjában a reguláris kifejezésmotor áll, amelyet a System.Text.RegularExpressions.Regex .NET 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.

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

A reguláris kifejezésobjektum-modell áttekintését a Reguláris kifejezésobjektum-modell című témakörben tekintheti meg.

A reguláris kifejezés nyelvével kapcsolatos további információkért tekintse meg a Reguláris kifejezés nyelve – Rövid útmutató című témakört, vagy töltse le és nyomtassa ki az alábbi brosúrák egyikét:

Reguláris kifejezési példák

Az String osztály sztringkeresési és cseremetszeteket tartalmaz, amelyeket akkor használhat, ha literális sztringeket szeretne keresni egy nagyobb sztringben. 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

System.Text.RegularExpressions A nem megbízható bemenetek feldolgozásakor időtúllépést kell megadni. A rosszindulatú felhasználók adhatnak RegularExpressionsmeg bemenetet a szolgáltatásmegtagadási támadáshoz. ASP.NET core framework API-k, amelyek időtúllépést használnak RegularExpressions .

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. Az osztály például azonosítja a TagRegex kezdőcímkéket egy sztringben, az CommentRegex osztály pedig ASP.NET megjegyzéseket egy sztringben.

1. példa: Részszűrések 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ési minta (Mr\.? |Mrs\.? |Miss |Ms\.? ) megegyezik a "Mr", "Mr. ", Mrs", "Mrs.", "Miss", "Ms" vagy "Ms. " előfordulásával. A metódus hívása Regex.Replace lecseréli a megfeleltethető sztringet String.Empty; más szóval eltávolítja azt az eredeti sztringbő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("{0} (duplicates '{1}') at position {2}",
                           match.Value, match.Groups[1].Value, 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 Kezdje egy szóhatáron.
(\w+?) Egy vagy több szó karakterének egyeztetése, de a lehető legkevesebb karakter. Együtt alkotnak egy csoportot, amelyet nevezhetünk \1.
\s Egyezik egy szóköz karakterrel.
\1 Egyezzen az alsztringel, amely megegyezik a nevesített csoportéval \1.
\b Egy szóhatár egyeztetése.

A Regex.Matches metódus neve normál kifejezési beállításokkal van beállítva RegexOptions.IgnoreCase. Ezért a kis- és nagybetűk közötti egyeztetési művelet érzéketlen, a példa pedig duplikációként azonosítja az "Ez ez" alsztringet.

A bemeneti sztring tartalmazza az "ez? Ez a". 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 a reguláris kifejezések erejét és a rugalmasságot szemlélteti. A NET globalizációs funkciói. Az objektum segítségével NumberFormatInfo 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 értékké Decimal , é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 {0} matches.", matches.Count);

      // 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 {0:C2}.", expenses[expenses.Count - 1]);
      else
         Console.WriteLine("The expenses total {0:C2}.", total);
   }
}
// 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.

Egy olyan számítógépen, amelynek jelenlegi kultúrája angol – Egyesült Államok (en-US), a példa dinamikusan létrehozza 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 meg kell próbálnia a sztring végén kezdeni 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* Üres szóköz karakter nulla vagy több előfordulását keresi.
[-+]? Keressen nulla vagy egy pozitív vagy negatív előjelet.
([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 lekérhetők a tulajdonság által Match.Groups visszaadott objektum második Group objektumábólGroupCollection. A gyűjtemény első eleme a teljes egyezé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 tizedesjegyet.
(\.[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 az objektumhoz MatchCollection hozzáad egyMatch, az egyezéssel kapcsolatos információkat tartalmazó objektumot.

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.
A 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.
A 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 Studióban

Referencia