تفاصيل سلوك التعبير العادي

مقالة
11/01/2010

مشغّل التعبيرات العادية في .NET Framework هو مطابق للتعبيرات العادية عن طريق التعقب التراجعي والذي يدمج مشغّل تقليدي غير الحتمي محدد إنساني (NFA) مثل تلك المستخدمة من قبل Perl و Python و Emacs و Tcl. و هذا يميزها عن مشغلات التعبيرات العادية الحتمية النقية المحددة الانسانية (DFA) الأسرع ولكن أكثر محدودية مثل تلك المستخدمة في awk أو egrep أو lex. و هذا أيضاً يميزها عن NFAs POSIX القياسية ولكنها أبطأ. يصف القسم التالي ثلاثة أنواع من العادية تعبير engines، وتشرح لماذا يتم تطبيق عادي تعبير s في the.NET إطار عمل باستخدام مشغل NFA تقليدية.

فوائد مشغل NFA

عند تنفيذ المشغلات DFA مطابقة نقش، ترتيب معالجة هو بواسطة سلسلة إدخال. المشغل يبدأ في بداية سلسلة إدخال وتستمر عملية بشكل تسلسلي إلى تحديد ما إذا كان الحرف التالي يطابق النموذج تعبير عادي. يمكن أن تضمن ل مطابقة السلسلة أطول المحتملة. حيث أنها لا اختبار نفس الحرف مرتين، مشغلات DFA لا تعتمد backtracking. ومع ذلك، لأنه يتضمن مشغل DFA الولاية محدودة فقط، لا مطابقة نقش مع backreferences، ولأن لا بناء توسيع صريحة، فإنه لا يمكن يلتقط subexpressions.

على عكس محركات DFA، عند تنفيذ المشغلات NFA التقليدية نقش مطابقة، ترتيب معالجة هو بواسطة نمط تعبير عادي. كما يقوم بمعالجة عنصر لغة التي يستخدمها المشغل التلائمات greedy؛ التي هو، يتوافق مع قدر من سلسلة إدخال كما أنه من الممكن. ولكن ذلك أيضا بحفظ حالته بعد مطابقة subexpression نجاح. إذا فشل التلائمات أخيرا، يمكن إرجاع المشغل إلى الولاية محفوظة حتى أنه يمكنك محاولة التلائمات إضافى. تعرف هذه العملية من abandoning مطابقة subexpression ناجحة بحيث يمكن أيضا أن يطابق عناصر اللغة لاحقاً في تعبير عادي backtracking . تستخدم محركات NFA backtracking إلى اختبار الجميع expansions المحتملة من تعبير عادي في ترتيب معين وقبول التطابق أول. لأن بناء مشغل NFA تقليدية توسيع محدد تعبير عادي الحصول على تطابق بنجاح، فإنه يمكن يلتقط التلائمات subexpression و backreferences التلائمات. على الرغم من ذلك، لأن NFA تقليدية backtracks، فإنه يمكن زيارة نفس الحالة عدة مرة/مرات في الولاية وصول في الحالة عبر مسارات مختلفة. ونتيجة لذلك، يمكن تشغيلها إطرادياً ببطء في أسوأ الحالات. لأن يقبل مشغلات NFA تقليدية أول التلائمات للبحث عن، فإنه يمكن أيضا المغادرة undiscovered تطابقات (من الممكن أن تكون أطول) أخرى.

مشغّلات NFA POSIX تشبه مشغّلات NFA التقليدية، فيما عدا أنها تتابع التعقب التراجعي حتى يمكنها أن تضمن انها عثرت على التطابق الأطول المحتمل. ونتيجة لذلك، مشغل NFA POSIX هو أبطأ من مشغل NFA "تقليدية"، ويفضل عند استخدام مشغل NFA POSIX، لا يمكن مستخدمو مطابقة أقصر عبر كلمة مرور أطول بتغيير ترتيب بحث backtracking.

يتم favored مشغلات NFA التقليدية بواسطة المبرمجين لأنه كان يقدم تحكم أكبر سلسلة مطابقة من مشغلات DFA أو NFA POSIX. على الرغم من أنه، في أسوأ الحالات، فإنها يمكن أن يعمل ببطء، يمكن قم إلى العثور على تطابقات في وقت خطي أو متعدد الحدود باستخدام أنماط تقليل ambiguities والحد من backtracking. بمعنى آخر، على الرغم من أن تبادل مشغلات NFA الأداء للطاقة ومرونة، في معظم الحالات كان يقدم أداء جيدا لمقبول إذا كان تعبير عادي هو well-written وتجنب الحالات في أي backtracking ينخفض أداء exponentially.

قدرات مشغّلات .NET Framework

إلى تأخذ فوائد الفوائد التي ستنجم عن مشغل NFA التقليدية مشغل تعبير عادي من برنامج.NET Framework يتضمن التعيين كاملة من بنيات إلى تمكين المبرمجين إلى قم مشغل backtracking. يمكن استخدام هذه المنشاءات للعثور على التطابقات بشكل أسرع أو لتفضيل توسعات معينة علي اخري.

ميزات غير ذلك من.NET Framework العادي تعبير مشغل تتضمن ما يلي:

البطيئة quantifiers: ??,*?,+?,{n,m}?. معرفة هذه بنيات مشغل backtracking إلى بحث الحد الأدنى لتكرار أولاً. وفي المقابل، سيحاول محدد الكمية الجشع العادية أن يطابق أكثر عدد من التكرارات أولاً. يلي مثال يوضح الفرق بين الاثنين. يطابق تعبير عادي جملة تنتهي برقم، ومجموعة الالتقاط هو تهدف إلى يفك الضغط هذا الرقم. تعبير عادي .+(\d+)\.تتضمن greedy quantifier .+، مما يؤدي إلى مشغل تعبير عادي إلى التقاط أرقام الأخيرة رقم. في تباين، تعبير عادي .+?(\d+)\.يتضمن quantifier البطيئة .+?، مما يؤدي إلى مشغل التعبير العادي لالتقاط الرقم بالكامل.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim greedyPattern As String = ".+(\d+)\."
      Dim lazyPattern As String = ".+?(\d+)\."
      Dim input As String = "This sentence ends with the number 107325."
      Dim match As Match

      ' Match using greedy quantifier .+.
      match = Regex.Match(input, greedyPattern)
      If match.Success Then
         Console.WriteLine("Number at end of sentence (greedy): {0}", 
                           match.Groups(1).Value)
      Else
         Console.WriteLine("{0} finds no match.", greedyPattern)
      End If

      ' Match using lazy quantifier .+?.
      match = Regex.Match(input, lazyPattern)
      If match.Success Then
         Console.WriteLine("Number at end of sentence (lazy): {0}", 
                           match.Groups(1).Value)
      Else
         Console.WriteLine("{0} finds no match.", lazyPattern)
      End If
   End Sub
End Module
' The example displays the following output:
'       Number at end of sentence (greedy): 5
'       Number at end of sentence (lazy): 107325

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string greedyPattern = @".+(\d+)\.";
      string lazyPattern = @".+?(\d+)\.";
      string input = "This sentence ends with the number 107325.";
      Match match;

      // Match using greedy quantifier .+.
      match = Regex.Match(input, greedyPattern);
      if (match.Success)
         Console.WriteLine("Number at end of sentence (greedy): {0}", 
                           match.Groups[1].Value);
      else
         Console.WriteLine("{0} finds no match.", greedyPattern);

      // Match using lazy quantifier .+?.
      match = Regex.Match(input, lazyPattern);
      if (match.Success)
         Console.WriteLine("Number at end of sentence (lazy): {0}", 
                           match.Groups[1].Value);
      else
         Console.WriteLine("{0} finds no match.", lazyPattern);
   }
}
// The example displays the following output:
//       Number at end of sentence (greedy): 5
//       Number at end of sentence (lazy): 107325

يتم تعريف greedy والبطيئة إصدارات هذا تعبير عادي كـ هو موضح في الجدول التالي. `

النمط	الوصف
.+(greedy quantifier)	مطابقة تواجد واحد على الأقل لأي حرف. يؤدي هذا المشغل تعبير عادي إلى مطابقة السلسلة بأكملها، وبعد ذلك إلى backtrack حسب الحاجة إلى تتطابق مع بقية نقش.
.+?(quantifier البطيئة)	مطابقة تواجد واحد على الأقل لأي حرف، ولكنه يطابق أقل عدد ممكن.
(\d+)	مطابقة حرف رقمي واحد على الأقل، وتعيين إلى التقاط أول المجموعة.
\.	يطابق نقطة (.).

ل المزيد من المعلومات حول quantifiers البطيئة، راجع محددو الكمية.

lookahead موجبة: (?=subexpression). وهذا ميزة يسمح محرك backtracking للرجوع إلى نفس المكان في نص بعد مطابقة subexpression. هو مفيدة للبحث عن كامل نص بواسطة التأكد من الأنماط المتعددة التي تبدأ من نفس الموقع. كما يسمح المشغل إلى التحقق من وجود سلسلة فرعية إنهاء المباراة دون تضمين السلسلة الفرعية في نص متطابق. يستخدم المثال التالي بموجب lookahead إلى استخراج الكلمات في جملة التي لا متبوعاً الترقيم.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[A-Z]+\b(?=\P{P})"
      Dim input As String = "If so, what comes next?"
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next   
   End Sub
End Module
' The example displays the following output:
'       If
'       what
'       comes

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]+\b(?=\P{P})";
      string input = "If so, what comes next?";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       If
//       what
//       comes

التعبير العادي \b[A-Z]+\b(?=\P{P}) مُعَرف كما هو موضح في الجدول التالي.

النمط	الوصف
\b	تبدأ التطابق عند حدود كلمة.
[A-Z]+	مطابقة أي حرف أبجدي واحد أو المزيد مرة/مرات. لأن Regex.Matchesأسلوب هو تسمى RegexOptions.IgnoreCaseخيار comparهوon هو عدم تحسس حالة الأحرف.
\b	إنهاء التطابق عند حدود الكلمة.
(?=\P{P})	انظر الأمام لتحديد ما إذا كان الحرف التالي هو الرمز علامة تنقيط. إذا كان ذلك هو لا، نجاح المطابقة.

ل المزيد من المعلومات حول assertions lookahead إيجابية، راجع تجميع البُنيَات.

lookahead السالبة: (?!subexpression). تضيف هذه الميزة الإمكانية إلى مطابقة تعبير فقط في حالة فشل subexpression إلى مطابقة. Th هو هو قوة خاصة تنقيح بحث، لأن ذلك هو غالباً أسهل بتوفير تعبير لهذه حالة التي يجب أن يتم حلها من تعبير بالنسبة للحالات التي يجب مُضمن. على سبيل المثال، من الصعب إلى كتابة تعبير للكلمات التي لا تبدأ باستخدام "لا". يستخدم المثال التالي lookahead السالبة إلى استثناء عليها.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b(?!non)\w+\b"
      Dim input As String = "Nonsense is not always non-functional."
      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
         Console.WriteLine(match.Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       is
'       not
'       always
'       functional

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(?!non)\w+\b";
      string input = "Nonsense is not always non-functional.";
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       is
//       not
//       always
//       functional

نمط تعبير عادي \b(?! non)\w+\b is defined as shown in the following table.

النمط	الوصف
\b	تبدأ التطابق عند حدود كلمة.
(?! non)	انظر الأمام للتأكد من أن السلسلة الحالي لا يبدأ بـ "لا". إذا كان ذلك، تفشل عملية المطابقة.
(\w+)	تتوافق مع حرف أو أكثر لكلمة.
\b	إنهاء التطابق عند حدود الكلمة.

لمزيد من المعلومات حول assertions lookahead سالبة، راجع تجميع البُنيَات.

تقييم شرطي: (?(تعبير)نعم|لا) و (?(اسم)نعم|لا), الموقع تعبير هو a subexpression إلى مطابقة, اسم هو the اسم of a capturing مجموعة, نعم هو the سلسلة إلى مطابقة if تعبير هو matched أو اسم هو a صالح, non-فارغ captured مجموعة, و لا هو the subexpression إلى مطابقة if تعبير ليس matched أو اسم ليس a صالح, non-فارغ captured مجموعة. تسمح هذه الميزة للمشغل للبحث باستخدام نمط بديل واحد أو المزيد، استناداً إلى الناتج السابق subexpression أو نتيجة لتأكيد ذات عرض صفر. يسمح هذا بشكل أكثر فعالية من backreference تسمح، ل مثال، تطابق subexpression استناداً إلى ما إذا كان تم مطابقة subexpression سابقة. تعبير عادي في المثال التالي يتوافق مع الفقرات المخصصة للاستخدام العام والداخلية. فقرات مخصص فقط للداخلية استخدم تبدأ ب <PRIVATE>علامة. نمط تعبير عادي ^(?<Pvt>\<PRIVATE\>\s)?(?(Pvt)((\w+\p{P}? \s)+)|((\w+\p{P}? \s)+))\r?$ uses conditional evaluation to assign the contents of paragraphs intended for public and for internal use to separate capturing groups. هذه الفقرات يمكن ثم يتم معالجة بشكل مختلف.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "<PRIVATE> This is not for public consumption." + vbCrLf + _
                            "But this is for public consumption." + vbCrLf + _
                            "<PRIVATE> Again, this is confidential." + vbCrLf
      Dim pattern As String = "^(?<Pvt>\<PRIVATE\>\s)?(?(Pvt)((\w+\p{P}?\s)+)|((\w+\p{P}?\s)+))\r?$"
      Dim publicDocument As String = Nothing
      Dim privateDocument As String = Nothing

      For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
         If match.Groups(1).Success Then
            privateDocument += match.Groups(1).Value + vbCrLf
         Else
            publicDocument += match.Groups(3).Value + vbCrLf   
            privateDocument += match.Groups(3).Value + vbCrLf
         End If  
      Next

      Console.WriteLine("Private Document:")
      Console.WriteLine(privateDocument)
      Console.WriteLine("Public Document:")
      Console.WriteLine(publicDocument)
   End Sub
End Module
' The example displays the following output:
'    Private Document:
'    This is not for public consumption.
'    But this is for public consumption.
'    Again, this is confidential.
'    
'    Public Document:
'    But this is for public consumption.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "<PRIVATE> This is not for public consumption." + Environment.NewLine + 
                     "But this is for public consumption." + Environment.NewLine + 
                     "<PRIVATE> Again, this is confidential.\n";  
      string pattern = @"^(?<Pvt>\<PRIVATE\>\s)?(?(Pvt)((\w+\p{P}?\s)+)|((\w+\p{P}?\s)+))\r?$";
      string publicDocument = null, privateDocument = null;

      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
      {
         if (match.Groups[1].Success) {
            privateDocument += match.Groups[1].Value + "\n";
         }
         else {
            publicDocument += match.Groups[3].Value + "\n";   
            privateDocument += match.Groups[3].Value + "\n";
         }  
      }

      Console.WriteLine("Private Document:");
      Console.WriteLine(privateDocument);
      Console.WriteLine("Public Document:");
      Console.WriteLine(publicDocument);
   }
}
// The example displays the following output:
//    Private Document:
//    This is not for public consumption.
//    But this is for public consumption.
//    Again, this is confidential.
//    
//    Public Document:
//    But this is for public consumption.

يتم تعريف نمط التعبير العادي كما هو موضح في الجدول التالية.

النمط	الوصف
^	البدء مطابقة في بداية السطر.
(?<Pvt>\<PRIVATE\>\s)?	مطابقة تواجد صفر أو واحد من سلسلة <PRIVATE>متبوعاً أبيض-مسافة حرف. تعيين مطابقة إلى مجموعة الالتقاط باسم Pvt.
(?(Pvt)((\w+\p{P}? \s)+)	إذا Pvtالتقاط مجموعة موجود، مطابقة تواجد واحد أو المزيد واحد أو المزيد أحرف الكلمة متبوعاً بالصفر أو فاصل علامة تنقيط واحدة متبوعاً أبيض-مسافة حرف. قم بتعيين سلسلة فرعية أول التقاط مجموعة.
\|((\w+\p{P}? \s)+))	إذا Pvtالتقاط المجموعة غير موجود، مطابقة تواجد واحد أو أكثر من واحد أو أكثر الكلمة أحرف متبوعة بصفر أو واحد فاصل علامات التنقيط، متبوعاً بأحرف المسافات البيضاء. تعيين السلسلة الفرعية إلى التقاط ثالث المجموعة.
\r?$	مطابقة إنهاء سطر أو نهايته سلسلة.

ل المزيد من المعلومات حول تقييم الشرطية, راجع تناوب الثوابت.

موازنة مجموعة ملفات تعريف: (?<name1-name2> subexpression). تسمح هذه الميزة للمحرك تعبير عادي إلى التمكن من مقطع صوتي بنيات المتداخلة مثل الأقواس أو فتح وإغلاق الأقواس. على سبيل المثال ، راجع تجميع البُنيَات.

nonbacktracking subexpressions (تعرف أيضا كـ greedy subexpressions): (?>subexpression). تسمح هذه الميزة لمشغل backtracking إلى ضمان أن subexpression يطابق فقط التطابق أول العثور على تلك subexpression، كما لو كانت تشغيل التعبير بعيداً عن التعبير الذي يحتوي على الصفحة الخاصة به. إذا لم تكن تستخدم بناء هذا، يمكن البحث backtracking من تعبير بقعة صغيرة بتغيير سلوك subexpression. على سبيل المثال، تعبير عادي (a+)\wمطابقة حرف واحد أو أكثر "a"، بالإضافة إلى حرف كلمة يتبع تسلسل حرف/ حروف "a"، وقم بتعيين تسلسل حرف/ حروف "a" أول يتطابق التقاط المجموعة، على الرغم من ذلك، إذا كان الحرف الأخير من سلسلة إدخال أيضا أنه "a"، \wعنصر اللغة وليس متضمناً في المجموعة التي تم التقاطها.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "aaaaa", "aaaaab" }
      Dim backtrackingPattern As String = "(a+)\w"
      Dim match As Match

      For Each input As String In inputs
         Console.WriteLine("Input: {0}", input)
         match = Regex.Match(input, backtrackingPattern)
         Console.WriteLine("   Pattern: {0}", backtrackingPattern)
         If match.Success Then 
            Console.WriteLine("      Match: {0}", match.Value)
            Console.WriteLine("      Group 1: {0}", match.Groups(1).Value)
         Else 
            Console.WriteLine("      Match failed.")
         End If   
      Next
      Console.WriteLine()            
   End Sub
End Module
' The example displays the following output:
'       Input: aaaaa
'          Pattern: (a+)\w
'             Match: aaaaa
'             Group 1: aaaa
'       Input: aaaaab
'          Pattern: (a+)\w
'             Match: aaaaab
'             Group 1: aaaaa

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "aaaaa", "aaaaab" };
      string backtrackingPattern = @"(a+)\w";
      Match match;

      foreach (string input in inputs) {
         Console.WriteLine("Input: {0}", input);
         match = Regex.Match(input, backtrackingPattern);
         Console.WriteLine("   Pattern: {0}", backtrackingPattern);
         if (match.Success) { 
            Console.WriteLine("      Match: {0}", match.Value);
            Console.WriteLine("      Group 1: {0}", match.Groups[1].Value);
         }
         else {
            Console.WriteLine("      Match failed.");
         }   
      }
      Console.WriteLine();            
   }
}
// The example displays the following output:
//       Input: aaaaa
//          Pattern: (a+)\w
//             Match: aaaaa
//             Group 1: aaaa
//       Input: aaaaab
//          Pattern: (a+)\w
//             Match: aaaaab
//             Group 1: aaaaa

تعبير عادي ((?>a+))\wيمنع هذا سلوك. لأن المتتالية على الجميع أحرف "a" مطابقة دون backtracking، تتضمن مجموعة الالتقاط الأولى المتتالية على الجميع أحرف "a". إذا لم يتم اتباع حرف/ حروف "a" بحرف واحد على الأقل لالمزيد غير ذلك من "ا" فشل التطابق.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "aaaaa", "aaaaab" }
      Dim nonbacktrackingPattern As String = "((?>a+))\w"
      Dim match As Match

      For Each input As String In inputs
         Console.WriteLine("Input: {0}", input)
         match = Regex.Match(input, nonbacktrackingPattern)
         Console.WriteLine("   Pattern: {0}", nonbacktrackingPattern)
         If match.Success Then 
            Console.WriteLine("      Match: {0}", match.Value)
            Console.WriteLine("      Group 1: {0}", match.Groups(1).Value)
         Else 
            Console.WriteLine("      Match failed.")
         End If   
      Next
      Console.WriteLine()            
   End Sub
End Module
' The example displays the following output:
'       Input: aaaaa
'          Pattern: ((?>a+))\w
'             Match failed.
'       Input: aaaaab
'          Pattern: ((?>a+))\w
'             Match: aaaaab
'             Group 1: aaaaa

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "aaaaa", "aaaaab" };
      string nonbacktrackingPattern = @"((?>a+))\w";
      Match match;

      foreach (string input in inputs) {
         Console.WriteLine("Input: {0}", input);
         match = Regex.Match(input, nonbacktrackingPattern);
         Console.WriteLine("   Pattern: {0}", nonbacktrackingPattern);
         if (match.Success) { 
            Console.WriteLine("      Match: {0}", match.Value);
            Console.WriteLine("      Group 1: {0}", match.Groups[1].Value);
         }
         else {
            Console.WriteLine("      Match failed.");
         }   
      }
      Console.WriteLine();            
   }
}
// The example displays the following output:
//       Input: aaaaa
//          Pattern: ((?>a+))\w
//             Match failed.
//       Input: aaaaab
//          Pattern: ((?>a+))\w
//             Match: aaaaab
//             Group 1: aaaaa

ل المزيد من المعلومات حول subexpressions nonbacktracking، راجع تجميع البُنيَات.

مطابقة لليمين إلى اليسار، الذي هو المحدد بواسطة توفير RegexOptions.RightToLeftخيار Regexالدالة الإنشائية الفئة أو المثيل ثابتة مطابقة الأسلوب. Th هو ميزة هو مفيدة عند يتم الآن البحث من اليمين يسار بدلاً اليسار لليمين، أو في حالات الموقع أنه هو أكثر فعالية لبدء مطابقة في جزء نقش بدلاً اليسار لليمين. كما يوضح المثال التالي استخدام يمين-إلى-الأيسر مطابقة يمكن تغيير سلوك greedy quantifiers. مثال بحثاً الثاني بالبحث عن جملة تنتهي برقم. اليسار-إلى-يمين بحث الذي يستخدمه greedy quantifier +يطابق إحدى الخانات الستة في الجملة، بينما يمين-بحث يسار إلى-مطابقة الجميع الخانات الستة. لوصف العادية تعبير نقش، راجع المثال الذي يوضح quantifiers البطيئة في هذا القسم.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim greedyPattern As String = ".+(\d+)\."
      Dim input As String = "This sentence ends with the number 107325."
      Dim match As Match

      ' Match from left-to-right using lazy quantifier .+?.
      match = Regex.Match(input, greedyPattern)
      If match.Success Then
         Console.WriteLine("Number at end of sentence (left-to-right): {0}", 
                           match.Groups(1).Value)
      Else
         Console.WriteLine("{0} finds no match.", greedyPattern)
      End If

      ' Match from right-to-left using greedy quantifier .+.
      match = Regex.Match(input, greedyPattern, RegexOptions.RightToLeft)
      If match.Success Then
         Console.WriteLine("Number at end of sentence (right-to-left): {0}", 
                           match.Groups(1).Value)
      Else
         Console.WriteLine("{0} finds no match.", greedyPattern)
      End If
   End Sub
End Module
' The example displays the following output:
'       Number at end of sentence (left-to-right): 5
'       Number at end of sentence (right-to-left): 107325

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string greedyPattern = @".+(\d+)\.";
      string input = "This sentence ends with the number 107325.";
      Match match;

      // Match from left-to-right using lazy quantifier .+?.
      match = Regex.Match(input, greedyPattern);
      if (match.Success)
         Console.WriteLine("Number at end of sentence (left-to-right): {0}", 
                           match.Groups[1].Value);
      else
         Console.WriteLine("{0} finds no match.", greedyPattern);

      // Match from right-to-left using greedy quantifier .+.
      match = Regex.Match(input, greedyPattern, RegexOptions.RightToLeft);
      if (match.Success)
         Console.WriteLine("Number at end of sentence (right-to-left): {0}", 
                           match.Groups[1].Value);
      else
         Console.WriteLine("{0} finds no match.", greedyPattern);
   }
}
// The example displays the following output:
//       Number at end of sentence (left-to-right): 5
//       Number at end of sentence (right-to-left): 107325

للحصول على مزيد من المعلومات حول مطابقة right-إلى-left، راجع خيارات التعبيرات العادية.

موجب و lookbehind السالبة: (?<=subexpression) ل lookbehind الموجبة، و (?<!subexpression) ل lookbehind سالبة. Th هو ميزة هو مماثلة ل lookahead، الذي هو dهوcussed سابقا في ترتيب هو الموضوع. لأن محرك التعبير العادي يسمح بالمطابقة الكاملة من اليمين لليسار، و تسمح التعبيرات العادية بالنظر الخلفي الغير المقيد. يمكن أيضا استخدام lookbehind الموجبة والسالبة لتجنب التداخل quantifiers عند subexpression المتداخلة هو مجموعة شاملة من تعبير الخارجية. التعابير النظامية مع quantifiers المتداخلة مثل غالباً بتقديم أداء ضعيف. على سبيل المثال، يتحقق المثال التالي من سلسلة تبدأ وتنتهي حرف أبجدي رقمي، وذلك أي حرف آخر في السلسلة هو واحد من مجموعة فرعية كبيرة. أنها تشكل جزء من تعبير عادي المستخدم للتحقق من صحة عناوين e-بريد؛ من أجل المزيد المعلومات، راجع كيفية القيام بما يلي: تحقق من ان السلاسل مكونه من تنسيق البريد الإلكتروني.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim inputs() As String = { "jack.sprat", "dog#", "dog#1", "me.myself", 
                                 "me.myself!" }
      Dim pattern As String = "^[A-Z0-9]([-!#$%&'.*+/=?^`{}|~\w])*(?<=[A-Z0-9])$"
      For Each input As String In inputs
         If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
            Console.WriteLine("{0}: Valid", input)
         Else
            Console.WriteLine("{0}: Invalid", input)
         End If   
      Next
   End Sub
End Module
' The example displays the following output:
'       jack.sprat: Valid
'       dog#: Invalid
'       dog#1: Valid
'       me.myself: Valid
'       me.myself!: Invalid

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "jack.sprat", "dog#", "dog#1", "me.myself", 
                          "me.myself!" };
      string pattern = @"^[A-Z0-9]([-!#$%&'.*+/=?^`{}|~\w])*(?<=[A-Z0-9])$";
      foreach (string input in inputs) {
         if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
            Console.WriteLine("{0}: Valid", input);
         else
            Console.WriteLine("{0}: Invalid", input);
      }
   }
}
// The example displays the following output:
//       jack.sprat: Valid
//       dog#: Invalid
//       dog#1: Valid
//       me.myself: Valid
//       me.myself!: Invalid

التعبير العادي ^[A-Z0-9]([-!#$%&'.*+/=?^`{}|~\w])*(?<=[A-Z0-9])$ مُعَرف كما هو موضح في الجدول التالي.

النمط	الوصف
^	تبدأ المباراة في بداية السلسلة.
[A-Z0-9]	مطابقة أي حرف رقمي أو رقمي هجائي. (المقارنة تحسس حالة الأحرف).
([-!#$%&'.+/=?^`{}\|~\w])	مطابقة صفر أو أكثر تواجدات أي حرف كلمة أو أي من حرف/ حروف التالية: -, !, #, $, %, &, ', ., *, +, /, =, ?, ^, `, {, }, \|, أو ~.
(?<=[A-Z0-9])	تبدو خلف إلى السابق حرف، التي يجب أن تكون رقمية أو أبجدية رقمية. (المقارنة تحسس حالة الأحرف).
$	الانتهاء مطابقة في إنهاء السلسلة.

لمزيد من المعلومات حول موجب و سالب lookbehind، راجع تجميع البُنيَات.

مواضيع ذات صلة

Title	الوصف
التراجع	توفر معلومات حول كيفية قيام تراجع التعبير-المنتظم بالتفرع للعثور على تطابقات بديلة.
عدم التراجع النظر-للأمام و النظر-للخلف	يوفر معلومات حول سلوك النظر للأمام و النظر للخلف للتعبير المنتظم.
محددات الكمية و المطابقات الفارغة	توضح كيف يمكنك تحديد العدد الأدنى والأقصى للتطابقات المطلوبة و كيف يعالج مشغل التعبير المنتظم المطابقات الفارغة.
التطابق التالي بعد مطابقة فارغة	توضح كيف يتقدم مشغّل التعبير المنتظم عبر سلسلة بعد تطابقات فارغة.
التحويل البرمجي و إعادة الاستخدام	توفر معلومات حول التحويل البرمجي و إعادة استخدام التعبيرات المنتظمة لزيادة الأداء.
أمان مؤشر الترابط	توفير معلومات حول تعبير عادي مؤشر ترابط أمان ويشرح متى يجب يزامن الوصول إلى تعبير عادي الكائنات.
التعبيرات العادية في .NET Framework	يوفر نظرة عامة على جانب لغة البرمجة للتعبيرات المنتظمة.
نموذج كائن التعبير العادي	توفر معلومات و أمثلة تعليمات برمجية تقوم بتوضيح كيفية استخدام فئات التعبيرات المنتظمة.
أمثلة علي التعبيرات العادية	تحتوي على أمثلة تعليمات برمجية تقوم بتوضيح كيفية استخدام فئات التعبيرات المنتظمة في التطبيقات الشائعة.
عناصر اللغة العاديه	توفير معلومات حول المجموعة من حرف/ حروف وعوامل التشغيل التي يمكنك استخدامها لتعريف بنية تعابير عادية.

المرجع

System.Text.RegularExpressions

مشاركة عبر

تفاصيل سلوك التعبير العادي

فوائد مشغل NFA

قدرات مشغّلات .NET Framework

مواضيع ذات صلة

المرجع

الموارد الإضافية