الفرق بين المراجعتين ل"Ruby/Regexp"

من موسوعة حسوب
اذهب إلى التنقل اذهب إلى البحث
سطر 90: سطر 90:
  
 
يمكن جعل الحروف الخاصة الطماعة قانعة باتباعها بالحرف <code>[[Ruby/Regexp/3D~|=~]]</code>. كلا النمطين أدناه يتطابقان مع السلسلة النصية. يستخدم الأول مُكمما طماعًا، بحيث يطابق ". +" السلسة النصية "<a> " ؛ أما الثاني فيستخدم مكمما قانعا،بحيث يطابق '.+?'السلسلة النصية '<a>': <code>[[Ruby//class-Regexp-label-Grouping|¶]]</code> المكممات المتبوعة بالعلامة + تُطابق  تملكيًا (possessively): فبمجرد أن تُطابق لا يتراجع. تتصرف مثل المكممات الطماعة، ولكنها ترفض "التخلي" عن الأجزاء التي طابقتها حتى لو كان ذلك قد يُفشل كامل المطابقة. الالتقاط<code>[aeiou]\w[aeiou]\w</code> <code>(?:</code> يمكن استخدام الأقواس لأجل الالتقاط (capturing). يمكن لاحقًا التأشير إلى النص المتضمن في مجموعة الأقواس  بالعدد n. داخل النمط استخدم <code>)</code> ؛ أما خارج النمط فاستخدم <code>\2</code>. في المثال أدناه، يتم التقاط السلسلة النصية "at" بواسطة الزوج الأول من الأقواس، ثم يشار إليها لاحقًا باستخدام
 
يمكن جعل الحروف الخاصة الطماعة قانعة باتباعها بالحرف <code>[[Ruby/Regexp/3D~|=~]]</code>. كلا النمطين أدناه يتطابقان مع السلسلة النصية. يستخدم الأول مُكمما طماعًا، بحيث يطابق ". +" السلسة النصية "<a> " ؛ أما الثاني فيستخدم مكمما قانعا،بحيث يطابق '.+?'السلسلة النصية '<a>': <code>[[Ruby//class-Regexp-label-Grouping|¶]]</code> المكممات المتبوعة بالعلامة + تُطابق  تملكيًا (possessively): فبمجرد أن تُطابق لا يتراجع. تتصرف مثل المكممات الطماعة، ولكنها ترفض "التخلي" عن الأجزاء التي طابقتها حتى لو كان ذلك قد يُفشل كامل المطابقة. الالتقاط<code>[aeiou]\w[aeiou]\w</code> <code>(?:</code> يمكن استخدام الأقواس لأجل الالتقاط (capturing). يمكن لاحقًا التأشير إلى النص المتضمن في مجموعة الأقواس  بالعدد n. داخل النمط استخدم <code>)</code> ؛ أما خارج النمط فاستخدم <code>\2</code>. في المثال أدناه، يتم التقاط السلسلة النصية "at" بواسطة الزوج الأول من الأقواس، ثم يشار إليها لاحقًا باستخدام
 +
 +
 +
‎</syntaxhighlight>
 +
يعيد التابع <code>[[Ruby/Regexp/match|#match]]</code> كائنًا من النوع <code>[[Ruby/MatchData|MatchData]]</code> والذ يجعل النص الذي تم التقاطه متاحًا عبر معامل الفهرسة []:
 +
<syntaxhighlight lang="ruby">/[csh](..) [csh]\1 in/.match("The cat sat in the hat")[1] #=> 'at'
 +
‎</syntaxhighlight>
 +
يمكن أن الرجوع إلى المجموعات الملتقطة باسمها في حال تعريف بالصياغة <code>(?<</code>name<code>>)</code> أو <code>(?'</code>name<code>')</code>.
 +
<syntaxhighlight lang="ruby">/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")
 +
  #=> #<MatchData "$3.67" dollars:"3" cents:"67">
 +
/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")[:dollars] #=> "3"
 +
‎</syntaxhighlight>
 +
يمكن الرجوع إلى المجموعات المُسماة بواسطة <code>\k<</code>name<code>></code>، حيث name هو اسم المجموعة.
 +
<syntaxhighlight lang="ruby">/(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
 +
  #=> #<MatchData "ototo" vowel:"o">
 +
‎</syntaxhighlight>
 +
ملاحظة: لا يمكن للتعبير النمطي استخدام المراجع المسماة (named backreferences) والمراجع الرقمية (numbered backreferences) في وقت واحد. عند استخدام مجموعات الالتقاط المسماة (named capture groups) مع تعبير نمطي حرفي على الجانب الأيسر من التعبير والمعامل <code>[[Ruby/Regexp/3D~|=~]]</code>، فستم تخزين النص الذي تم التقاطه في متغيرات محلية تحمل أسماء مشابهة.
 +
<syntaxhighlight lang="ruby">/\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ "$3.67" #=> 0
 +
dollars #=> "3"
 +
‎</syntaxhighlight>
 +
التجميع <code>[[Ruby//class-Regexp-label-Grouping|¶]]</code> <code>[[Ruby//top|↑]]</code> تُجمّع الأقواس أيضًا التعابير التي تُطوّقها، مما يسمح بتحديدها كمجموعة واحدة. يتطابق النمط أدناه مع حرف متحرك (vowel) متبوعًا بحرفي كلمة (word characters):
 +
<syntaxhighlight lang="ruby">/[aeiou]\w{2}/.match("Caenorhabditis elegans") #=> #<MatchData "aen">
 +
‎</syntaxhighlight>
 +
بينما يتطابق النمط التالي مع حرف متحرك يتبعه حرف كلمة، مرتين ، مثل <code>[aeiou]\w[aeiou]\w</code>: "enor".
 +
<syntaxhighlight lang="ruby">/([aeiou]\w){2}/.match("Caenorhabditis elegans")
 +
  #=> #<MatchData "enor" 1:"or">
 +
‎</syntaxhighlight>
 +
يوفر التعبير <code>(?:</code> إمكانية التجميع <code>)</code> لكن بدون التقاط. وهذا يعني، أنه يُجمّع التعابير التي يحتوي عليها في وحدة غير قابلة للتجزيئ دون إنشاء مرجع إليه (backreference). هذا يفيد في تحسين الأداء على حساب إضرار طفيف بقابلية القراءة. الزوج الأول من الأقواس يلتقط "n"، أما الثاني فيلتقط "ti". تتم الإشارة إلى المجموعة الثانية لاحقًا باستخدام المرجع <code>\2</code>:
 +
<syntaxhighlight lang="ruby">/I(n)ves(ti)ga\2ons/.match("Investigations")
 +
  #=> #<MatchData "Investigations" 1:"n" 2:"ti">
 +
‎</syntaxhighlight>
 +
لقط أصبح الزوج الأول من الأقواس غير قابل للالتقاط بسبب استخدام "؟:"، لذلك قسيتطابق مع "n"، ولكنه لن ينشئ مرجعًا إليه. وبالتالي ، فالمرجع <code>\1</code> يشير الآن إلى "ti".
 +
<syntaxhighlight lang="ruby">/I(?:n)ves(ti)ga\1ons/.match("Investigations")
 +
  #=> #<MatchData "Investigations" 1:"ti">
 +
‎</syntaxhighlight>
 +
<code>[[Ruby//class-Regexp-label-Atomic+Grouping|¶]]</code> <code>[[Ruby//top|↑]]</code> التجميع الذري يمكن جعل التجميعات ذرية بواسطة <code>(?></code>pat<code>)</code>. هذا سيؤدي إلى مطابقة التعبير الجزئي (subexpression) بشكل مستقل عن بقية التعبير، بحيث أنّ ما يطابقه سيصبح ثابتًا لبقية المطابقة، ما لم يتم التخلي عن التعبير الجزئي بأكمله وإعادة النظر فيه لاحقًا. بهذه الطريقة، يعامل pat باعتبارها وحدة غير قابلة للتجزيئ. يتم استخدام التجميع الذري عادة لتحسين أداء الأنماط، وكذلك لمنع إنشاء مراجع (backtracking) بدون داعٍ. يتطابق <code>"</code> في النمط أدناه مع الحرف الأول من السلسلة النصية، ثم يُطابق <code>.*</code> علامة التنصيص ". يؤدي هذا إلى فشل المطابقة الإجمالية، وهكذا فالنص المطابق لـ <code>.*</code> يحدد مرجعه (backtracked) بموضع واحد ، مما يتيح الحرف النهائي للسلسلة النصية لأجل لمطابقة <code>"</code>
 +
<syntaxhighlight lang="ruby">/".*"/.match('"Quote"')    #=> #<MatchData "\"Quote\"">
 +
‎</syntaxhighlight>
 +
إذا تم تجميع <code>.*</code> ذريًا، فسيرفض إنشاء مرجع للعلامة "، على الرغم من أن هذا سيعني أن المطابقة الإجمالية ستفشل
 +
<syntaxhighlight lang="ruby">/"(?>.*)"/.match('"Quote"') #=> nil
 +
‎</syntaxhighlight>
 +
استدعاء التعابير الجزئية<code>[[Ruby//class-Regexp-label-Subexpression+Calls|¶]]</code> <code>[[Ruby//top|↑]]</code> تطابق الصياغة <code>\g<</code>name<code>></code> التعبير الجزئي السابق المسمى name، والذي يمكن أن يكون اسم مجموعة أو رقم. هذا يختلف عن التأشير في أنه يعيد تنفيذ المجموعة بدلاً من مجرد محاولة إعادة مطابقة نفس النص. يتطابق النمط الموالي مع حرف (حرف ويُحيلها إلى المجموعة <code>paren</code>، ويحاول استدعاء التعبير الجزئ للمجموعة <code>paren</code> مرة أخرى لكنه يفشل، ثم يطابق محرفا [literal]):
 +
<syntaxhighlight lang="ruby">/\A(?<paren>\(\g<paren>*\))*\z/ =~ '()'
 +
/\A(?<paren>\(\g<paren>*\))*\z/ =~ '(())' #=> 0
 +
# ^1
 +
#      ^2
 +
#          ^3
 +
#                ^4
 +
#      ^5
 +
#          ^6
 +
#                      ^7
 +
#                      ^8
 +
#                      ^9
 +
#                          ^10
 +
‎</syntaxhighlight>
 +
*يطابق بداية السلسلة النصية، أي قبل الحرف الأول.  *يدخل مجموعة التقاط مسماة تسمى <code>paren</code> *يطابق المحرف (، الحرف الأول في السلسلة النصية *يستدعي المجموعة <code>paren</code> مرة أخرى، أي يعاود الرجوع (recurses) مرة أخرى إلى الخطوة الثانية *يعيد الدخول إلى المجموعة <code>paren</code> *يطابق المحرف (، الحرف الثاني في السلسلة النصية *يحاول استدعاء <code>paren</code> للمرة الثالثة، ولكن يفشله، لأن ذلك من شأنه أن يمنع مطابقة ناجحة شاملة *يطابق المحرف )، أي الحرف الثالث في السلسلة النصية. يحدد نهاية الاستدعاء العودي (recursive) الثانية *يطابق المحرف )، الحرف الرابع في السلسلة النصية *يطابق نهاية السلسلة النصية البدائل<code>[[Ruby//class-Regexp-label-Alternation|¶]]</code> <code>[[Ruby//top|↑]]</code> يُؤلّف الحرف الخاص (<code>|</code>) بين تعبيرين في تعبير واحد يطابق أيًا من تلك التعبيرات. كل تعبير هو بديل ممكن.
 +
<syntaxhighlight lang="ruby">/\w(and|or)\w/.match("Feliformia") #=> #<MatchData "form" 1:"or">
 +
/\w(and|or)\w/.match("furandi")    #=> #<MatchData "randi" 1:"and">
 +
/\w(and|or)\w/.match("dissemblance") #=> nil
 +
‎</syntaxhighlight>
 +
خاصيات الحروف<code>[[Ruby//class-Regexp-label-Character+Properties|¶]]</code> <code>[[Ruby//top|↑]]</code> تُطابق الصياغة <code>\p{}</code> الحروف ذات الخاصية المحددة، مثل مجموعات أقواس POSIX.  *<code>/\p{Alnum}/</code> - حرف أبجدي أو رقمي *<code>/\p{Alpha}/</code> - حرف أبجدي *<code>/\p{Blank}/</code> - مسافة بيضاء أو علامة تبويب (tab) *<code>/\p{Cntrl}/</code> - حرف تحكم *<code>/\p{Digit}/</code> - رقم *<code>/\p{Graph}/</code> - حرف غير فارغ (يستثني المسافات البيضاء وأحرف تحكم وما شابه) *<code>/\p{Lower}/</code> - حرف أبجدي صغير *<code>/\p{Print}/</code> - مثل <code>\p{Graph}</code> ، ولكنه يتضمن المسافة البيضاء *<code>/\p{Punct}/</code> - علامة ترقيم *<code>/\p{Space}/</code> - حرف مسافة بيضاء (<code>[:blank:]</code> أو سطر جديد أو حرف يُعيد[carriage return]، إلخ)  *<code>/\p{Upper}/</code> - حرف أبجدي كبير *<code>/\p{XDigit}/</code> - رقم من الأرقام المسموح بها في الأعداد السداسي عشرية (على سبيل المثال ، 0-9a-fA-F) *<code>/\p{Word}/</code> - عنصر من إحدى مجموعات اليونيكود العامة التالية Letter، Mark، Number، Connector_Punctuation *<code>/\p{ASCII}/</code> - حرف من حروف ASCII. *<code>/\p{Any}/</code> - أي حرف من حروف اليونيكود (بما في ذلك الأحرف غير المعينة[unassigned]). *<code>/\p{Assigned}/</code> - حرف معين (assigned character). يمكن أيضًا مطابقة حرف من مجموعة اليونيكود General Category بالنمط <code>\p{</code>Ab<code>}</code> حيث Ab يمثل اختصار المجموعة كما هو موضح أدناه: <code>/\p{L}/</code> - 'Letter' <code>/\p{Ll}/</code> - 'Letter: Lowercase' <code>/\p{Lm}/</code> - 'Letter: Mark' <code>/\p{Lo}/</code> - 'Letter: Other' <code>/\p{Lt}/</code> - 'Letter: Titlecase' <code>/\p{Lu}/</code> - 'Letter: Uppercase <code>/\p{Lo}/</code> -' Letter: Other '<code>/\p{M}/</code> -' Mark '<code>/\p{Mn}/</code> -' Mark: Nonspacing '<code>/\p{Mc}/</code> -' Mark : Spacing Combining '<code>/\p{Me}/</code> -' Mark: Enclosing '<code>/\p{N}/</code> -' Number '<code>/\p{Nd}/</code> -' Number: Decimal Digit '<code>/\p{Nl}/</code> -' Number: Letter '<code>/\p{No}/</code> -' Number: Other '<code>/\p{P}/</code> -' Punctuation '<code>/\p{Pc}/</code> -' Punctuation: Connector ' <code>/\p{Pd}/</code> - 'Punctuation: Dash' <code>/\p{Ps}/</code> - 'Punctuation: Open' <code>/\p{Pe}/</code> - 'Punctuation: Close' XX XXX - 'علامات الترقيم: اقتباس أولي' <code>/\p{Pi}/</code> - 'علامات الترقيم: اقتباس نهائي' <code>/\p{Pf}/</code> - 'علامات الترقيم: أخرى' <code>/\p{Po}/</code> - 'Symbol' <code>/\p{S}/</code> - 'الرمز: Math' <code>/\p{Sm}/</code> - 'الرمز: Currency' <code>/\p{Sc}/</code> - 'Symbol: Currency' <code>/\p{Sc}/</code> - 'Symbol: Modifier' <code>/\p{Sk}/</code> - 'Symbol: Other' <code>/\p{So}/</code> - 'Separator' <code>/\p{Z}/</code> - 'Separator: Space' <code>/\p{Zs}/</code> - 'Separator: Line' <code>/\p{Zl}/</code> - 'Separator: Paragraph' <code>/\p{Zp}/</code> - 'Other' <code>/\p{C}/</code> - 'Other: Control '<code>/\p{Cc}/</code> -' Other: Format '<code>/\p{Cf}/</code> -' Other: Not Assigned '<code>/\p{Cn}/</code> -' Other: Private Use '<code>/\p{Co}/</code> -' Other: Surrogate 'Lastly، <code>/\p{Cs}/</code> match for Unicode script. النصوص التالية مدعومة: العربية ، الأرمنية ، البالية ، البنغالية ، Bopomofo ، Braille ، Buginese ، Buhid ، Canadian_Aboriginal ، Carian ، Cham ، Cherokee ، Common ، Coptic ، المسمارية ، Cypriot ، السيريلية ، Deseret ، Devanagari ، الاثيوبية ، الجورجية ، Glagolitic ، القوطية ، اليونانية ، الغوجاراتية ، Gurmukhi ، هان ، هانغول ، Hanunoo ، العبرية ، الهيراجانا ، ورثت ، الكانادا ، Katakana ، Kayah_Li ، Kharoshthi ، الخمير ، لاو ، اللاتينية ، Lepcha ، Limbu ، Linear_B ، Lycian ، Lydian ، المالايالامية ، المنغولية ، ميانمار ، New_Tai_Lue، Nko، Ogham، Ol_Chiki، Old_Italic، Old_Persian، Oriya، Osmanya، Phags_Pa، Phoenician، Rejang، Runic، Saurashtra، Shavian، Sinhala، Sundanese، Syloti_Nagri، Syriac، Tagalog، Tagbanwa، Tai_Le، Tamil، Telugu، Thaana، Thai، التبتية ، تيفيناغ ، الأوغاريتية ، فاي ، ويي. محرفق اليونيكود U+06E9 يُسمى "ARABIC PLACE of SAJDAH" (موضع سجدة)، وينتمي إلى الخط العربي: <code>\p{}</code> يمكن عكس جميع خصائص الأحرف عن طريق إضافة البادئة (
 +
<syntaxhighlight lang="ruby">/\p{Arabic}/.match("\u06E9") #=> #<MatchData "\u06E9">
 +
‎</syntaxhighlight>
 +
) إلى أسمائها. الحرف "A" ليس مُتضمّنًا في مجموعة اليونيكود Ll [تعني (Letter; Lowercase)]، لذلك تنجح المطابقة التالية: <code>^</code>
 +
<syntaxhighlight lang="ruby">/\p{^Ll}/.match("A") #=> #<MatchData "A">
 +
‎</syntaxhighlight>
 +
<code>[[Ruby//class-Regexp-label-Anchors|¶]]</code> Anchors المراسي (Anchors) هي حروف خاصة تُطابق مواضع معدومة الطول بين الأحرف، وتربط المطابقة بموضع معين.  *<code>[[Ruby//top|↑]]</code> - تطابق بداية السطر *<code>^</code> - تطابق نهاية السطر *<code>$</code> - تطابق بداية السلسلة النصية.  *<code>\A</code> - تطابق نهاية السلسلة النصية. إذا انتهت السلسلة النصية بسطر جديد، فستُطابق الموضع الموجود قبل السطر الجديد مباشرة *<code>\Z</code> - تطابق نهاية السلسلة النصية <code>\z</code> - تطابق أول موضع مطابقة: في توابع مثل <code>\G</code> و <code>String#gsub</code>، تتغير عند كل تكرار. تتطابق في البداية مع بداية الموضوع، وفي كل تكرار تطابق مكان انتهاء المطابقة الأخيرة. <code>String#scan</code> في التوابع التي تأخذ موضعًا(اختياريًا)، مثل
 +
<syntaxhighlight lang="ruby">"    a b c".gsub(/ /, '_')    #=> "____a_b_c"
 +
"    a b c".gsub(/\G /, '_')  #=> "____a b c"
 +
‎</syntaxhighlight>
 +
و <code>Regexp#match</code>، ستُطابق مكان بدء البحث. <code>String#match</code> *
 +
<syntaxhighlight lang="ruby">"hello, world".match(/,/, 3)    #=> #<MatchData ",">
 +
"hello, world".match(/\G,/, 3)  #=> nil
 +
‎</syntaxhighlight>
 +
- تطابق مواضع حدود الكلمات عندما تكون خارج الأقواس؛ وتطابق محرف التراجع backspace (0x08) عندما تكون داخل الأقواس *<code>\b</code> - تُطابق المواضع المخالفة لحدود الكلمات *<code>\B</code>pat<code>(?=</code> - المطالعة الأمامية الإيجابية (Positive lookahead assertion): تضمن أنّ الأحرف التالية تتطابق مع pat، ولكن لا تتضمن تلك الأحرف في النص المُطابق *<code>)</code>pat<code>(?!</code> - المطالعة الأمامية السلبية (Negative lookahead assertion): تضمن أنّ الأحرف التالية لا تتطابق مع pat، ولكن لا تتضمن تلك الأحرف في النص المُطابق *<code>)</code>pat<code>(?<=</code> -المطالعة الخلفية الإيجابية (Positive lookbehind assertion): تضمن تطابق الأحرف السابقة مع pat، ولكنها لا تتضمّن تلك الأحرف في النص المُطابق *<code>)</code>pat<code>(?<!</code> - المطالعة الخلفية الإيجابية (Negative lookbehind assertion): تضمن أنّ الأحرف السابقة لا تتطابق مع pat، ولكنها لا تتضمن تلك الأحرف في النص المُطابق إذا لم يتم وضع مرساة (anchored) للنمط، فيمكنه أن يبدأ من أي نقطة في السلسلة النصية: <code>)</code> إرساء النمط عند بداية السلسلة النصية يفرض بدء المطابقة هناك. في المثال الآتي، لا تظهر "real" في بداية السلسلة النصية، لذلك تفشل المطابقة:
 +
<syntaxhighlight lang="ruby">/real/.match("surrealist") #=> #<MatchData "real">
 +
‎</syntaxhighlight>
 +
تفشل المطابقة أدناه لأنه على الرغم من أن "Demand" تحتوي "and" ، فإنّ النمط لا يظهر عند حدود الكلمات.
 +
<syntaxhighlight lang="ruby">/\Areal/.match("surrealist") #=> nil
 +
‎</syntaxhighlight>
 +
في حين أنّه في المثال التالي السلسلة النصية "and" تم إرساؤها عند الحدود غير الكلِمية، لذلك، فبدلاً من مطابقة "and" الأولى، فستتطابق مع الحرف الرابع من "demand" بدلاً من ذلك:
 +
<syntaxhighlight lang="ruby">/\band/.match("Demand")
 +
‎</syntaxhighlight>
 +
يستخدم النمط التالي المطالعة الأمامية الإيجابية و االمطالعة الخلفية الإيجابية لمطابقة النص الوارد في الوسوم (tags) دون تضمين الوسوم في المطابقة:
 +
<syntaxhighlight lang="ruby">/\Band.+/.match("Supply and demand curve") #=> #<MatchData "and curve">
 +
‎</syntaxhighlight>
 +
الخيارات
 +
<syntaxhighlight lang="ruby">/(?<=<b>)\w+(?=<\/b>)/.match("Fortune favours the <b>bold</b>")
 +
  #=> #<MatchData "bold">
 +
‎</syntaxhighlight>
 +
<code>[[Ruby//class-Regexp-label-Options|¶]]</code> يمكن أن يتبع محدد النهاية للتعبير النمطي بحرف واحد أو أكثر تمثل الخيارات التي تتحكم في كيفية مطابقة النمط.  *<code>[[Ruby//top|↑]]</code> - Ignore case *<code>/pat/i</code> - تجعل . تطابق محرف السطر الجديد <code>/pat/m</code> *<code>.</code> - تتجاهل المسافات البيضاء والتعليقات الموجودة في النمط *<code>/pat/x</code> - تنفّذ عملية الاستكمال <code>/pat/o</code> مرة واحدة فقط يمكن أيضًا تطبيق <code>#{}</code> و<code>i</code> و <code>m</code> على مستوى التعابير الجزئية عبر الصياغة <code>x</code>on<code>(?</code>off<code>-</code>، والتي تفعّل الخيارات on، وتعطّل الخيارات off في التعبير المحاط بالأقواس. <code>)</code> كما يمكن استخدام الخيارات مع
 +
<syntaxhighlight lang="ruby">/a(?i:b)c/.match('aBc') #=> #<MatchData "aBc">
 +
/a(?i:b)c/.match('abc') #=> #<MatchData "abc">
 +
‎</syntaxhighlight>
 +
: <code>Regexp.new</code> وضع التباعد الحر و تعليقات
 +
<syntaxhighlight lang="ruby">Regexp.new("abc", Regexp::IGNORECASE)                    #=> /abc/i
 +
Regexp.new("abc", Regexp::MULTILINE)                      #=> /abc/m
 +
Regexp.new("abc # Comment", Regexp::EXTENDED)            #=> /abc # Comment/x
 +
Regexp.new("abc", Regexp::IGNORECASE | Regexp::MULTILINE) #=> /abc/mi
 +
‎</syntaxhighlight>
 +
<code>[[Ruby//class-Regexp-label-Free-Spacing+Mode+and+Comments|¶]]</code> كما ذُكر أعلاه، يتيح الخيار <code>[[Ruby//top|↑]]</code> وضع التباعد الحر. يتم تجاهل محارف المسافاة البيضاء داخل النمط، ويقدم محرف الشباك octothorpe (<code>x</code>) تعليقًا حتى نهاية السطر. يسمح هذا بتنظيم مكونات النمط بطريقة تجعله أكثر مقروئية. في المثال التالي يطابق النمط عددًا مع منازل عشرية اختيارية: <code>#</code> هناك عدة استراتيجيات لمطابقة المسافات البيضاء: *استخدم نمطًا مثل
 +
<syntaxhighlight lang="ruby">float_pat = /\A
 +
  [[:digit:]]+ # 1 or more digits before the decimal point
 +
  (\.          # Decimal point
 +
      [[:digit:]]+ # 1 or more digits after the decimal point
 +
  )? # The decimal point and following digits are optional
 +
\Z/x
 +
float_pat.match('3.14') #=> #<MatchData "3.14" 1:".14">
 +
‎</syntaxhighlight>
 +
أو <code>\s</code>.  *استخدم مسافات بيضاء مُخلّصة (escaped whitespace) مثل <code>\p{Space}</code>، أي مسافة مسبوقة بخط مائل عكسي.  *استخدم مجموعة حروف مثل <code>\</code>.  يمكن تضمين التعليقات في انماط غير النمط <code>[ ]</code> باستخدام الصياغة <code>x</code>comment<code>(?#</code>، حيث أن التعليق نص اعتباطي يتم تجاهله من محرك التعبير النمطي. لا يمكن أن تتضمن التعليقات المُتضمّنة في تعبير نمطي حرفي محرف إنهاء غير مُخلص (unescaped terminator characters). <code>)</code><code>[[Ruby/Encoding|Encoding]]</code> <code>[[Ruby//class-Regexp-label-Encoding|¶]]</code> يفترض أن تستخدام التعابير النمطية ترميز المصدر. يمكن تجاوز هذا بأحد المُعدِّلات التالية.  <code>[[Ruby//top|↑]]</code>pat<code>/</code> - UTF-8 <code>/u</code>pat<code>/</code> - EUC-JP <code>/e</code>pat<code>/</code> - Windows-31J <code>/s</code>pat<code>/</code> - ASCII-8BIT يمكن مطابقة تعبير نمطي مع سلسلة نصية عندما يتشاركان في الترميز، أو إن كان ترميز التعبير النمطي هو US-ASCII وترميز السلسلة النصية متوافق مع ASCII. إذا تمت محاولة المطابقة بين ترميزات غير متوافقة، فسيُطلق الاستثناء <code>/n</code>. تتحقق الدالة المنطقية <code>Encoding::CompatibilityError</code> مما إذا كان للتعبير النمطي ترميز ثابت، ومتوافق مع الترميز ASCII. يمكن تثبيت ترميز التعبير النمطي بشكل صريح عبر تمرير <code>Regexp#fixed_encoding?</code> كوسيط ثانٍ للتابع <code>Regexp::FIXEDENCODING</code>: <code>Regexp.new</code> متغيرات عامة مخصوصة
 +
<syntaxhighlight lang="ruby">r = Regexp.new("a".force_encoding("iso-8859-1"),Regexp::FIXEDENCODING)
 +
r =~ "a\u3042"
 +
  # raises Encoding::CompatibilityError: incompatible encoding regexp match
 +
  #        (ISO-8859-1 regexp with UTF-8 string)
 +
‎</syntaxhighlight>
 +
من المهم معرفة بعض المتغيرات العامة: *<code>[[Ruby//class-Regexp-label-Special+global+variables|¶]]</code> تكافئ <code>[[Ruby//top|↑]]</code>؛ *<code>$~</code> تحتوي كامل النص المتطابق؛ *<code>[[Ruby/Regexp/last_match|::last_match]]</code> تحتوي السلسلة النصية التي تسبق التطابق؛ *<code>$&</code> تحتوي السلسلة النصية التي تعقب التطابق؛ *<code>$`</code> و <code>$'</code> وهلم جرًا، تحتوي النص المُتطابق مع مجموعة الالتقاط الأولى، والثانية، وما إلى ذلك؛ *<code>$1</code> تحتوي آخر مجموعة مُلتقطة.  مثال: <code>$2</code> هذه المتغيرات العامة هي متغيرات مخصوصة بالمهام الفرعية (thread-local)، ومخصوصة بالتوابع (method-local). الأداء <code>$+</code>
 +
<syntaxhighlight lang="ruby">m = /s(\w{2}).*(c)/.match('haystack') #=> #<MatchData "stac" 1:"ta" 2:"c">
 +
$~                                    #=> #<MatchData "stac" 1:"ta" 2:"c">
 +
Regexp.last_match                    #=> #<MatchData "stac" 1:"ta" 2:"c">
 +
$&      #=> "stac"
 +
      # same as m[0]
 +
$`      #=> "hay"
 +
      # same as m.pre_match
 +
$'      #=> "k"
 +
      # same as m.post_match
 +
$1      #=> "ta"
 +
      # same as m[1]
 +
$2      #=> "c"
 +
      # same as m[2]
 +
$3      #=> nil
 +
      # no third group in pattern
 +
$+      #=> "c"
 +
      # same as m[-1]
 +
‎</syntaxhighlight>
 +
يمكن أن تؤدي بعض التوليفات غير السليمة في الصياغة إلى أداء سيئ جدا. انظر المثال التالي: <code>[[Ruby//class-Regexp-label-Performance|¶]]</code> تتم مطابقة الأنماط التالية على الفور كما هو متوقع: <code>[[Ruby//top|↑]]</code> أما النمط التالي فيستغرق وقتًا أطول بشكل ملحوظ:
 +
<syntaxhighlight lang="ruby">s = 'a' * 25 + 'd' + 'a' * 4 + 'c'
 +
#=> "aaaaaaaaaaaaaaaaaaaaaaaaadaaaac"
 +
‎</syntaxhighlight>
 +
يحدث هذا لأن ذرة في التعبير النمطي مٌكمّمة (quantified) بواسطة كل من الحرف
 +
<syntaxhighlight lang="ruby">/(b|a)/ =~ s #=> 0
 +
/(b|a+)/ =~ s #=> 0
 +
/(b|a+)*/ =~ s #=> 0
 +
‎</syntaxhighlight>
 +
والحرف
 +
<syntaxhighlight lang="ruby">/(b|a+)*c/ =~ s #=> 26
 +
‎</syntaxhighlight>
 +
بدون تحديد لمن منهما سيكون التحكم لرحف معين. عدم الوضوح ينتج عنه ينتج أداء خطي فائق (super-linear performance). (راجع Mastering Regular Expressions (3rd ed.)، pp 222 ، بواسطة Jeffery Friedl ، لإجراء تحليل متعمق). يمكن إصلاح هذه المشكلة عن طريق استخدام التجميع الذري، والذي يمنع التأشير غير الضروري: <code>+</code> يوضح المثال التالي حالة مشابهة، والتي استغرقت حوالي 60 ثانية للتنفيذ عندي: مطابقة سلسلة نصية مكونة 29 حرف "a" مقابل نمط مؤلف من 29 حرف "a" اختياري يليه 29 إلزاميًا على النحو التالي: <code>*</code> حروف "a" التسعة وعشرون الاختيارية تطابق السلسلة النصية، لكن هذا يمنع الحروف التسعة وعشروت الإلزامية الموالية من المطابقة. تتراجع روبي مرارًا وتكرارًا حتى تستوفي أكبر عدد ممكن من التطابقات الاختيارية دون التفريط في المطابقة التسعة وعشرين الإجبارية. من الواضح لنا أنه لا يمكن لأي من المطابقات الاختيارية أن تنجح، ولكن هذه الحقيقة ليست واضحة للأسف لروبي. أفضل طريقة لتحسين الأداء هي تقليل مقدار التراجع المطلوب إلى أقصى حد.  في هذه الحالة، بدلاً من المطابقة الفردية لـ 29 حرفًا اختياريًا، يمكن مطابقة مجال اختياريً دفعة واحدة عبر {0،29}:
 +
<syntaxhighlight lang="ruby">(start = Time.now) && /(b|a+)*c/ =~ s && (Time.now - start)
 +
  #=> 24.702736882
 +
(start = Time.now) && /(?>b|a+)*c/ =~ s && (Time.now - start)
 +
  #=> 0.000166571
 +
‎</syntaxhighlight>
 +
 +
 +
==توابع الصنف العامة (Public Class Methods)==
 +
===[[Ruby/Regexp/compile | التابع compile]]===
 +
اسم آخر للتابع <code>Regexp.new</code>
 +
===[[Ruby/Regexp/escape | التابع escape]]===
 +
يُخلّص (Escapes)  أي حرف يمكن أن يكون له معنى خاص في التعبير النمطي. ثم يعيد سلسلة نصية جديدة مُخلّصة، أو يعيد الكائن  (self) في حال عدم تخليص أي أحرف.  لكل سلسلة نصية str، ستكون قيمة <code>Regexp.new(Regexp.escape( str ))=~ str</code> مساوية للقيمة true.
 +
===[[Ruby/Regexp/last_match | التابع last_match]]===
 +
يُعيد  في الشكل الأول  كائن <code>[[Ruby/MatchData|MatchData]]</code> الذي تم إنشاؤه من آخر تطابق ناجح للنمط.  وهو مكافئ لقراءة المتغير العام المخصوص <code>$~</code> (راجع المتغيرات العامة المخصوصة في صفحة <code>[[Ruby/Regexp|Regexp]]</code> لمزيد من التفاصيل).
 +
===[[Ruby/Regexp/new | التابع new]]===
 +
ينشئ  تعبيرًا نمطيًا جديدًا من <code>pattern</code>، والذي يمكن أن يكون إما سلسلة نصية (<code>[[Ruby/String|String]]</code>) أو كائنًا من النوع <code>[[Ruby/Regexp|Regexp]]</code> (وفي هذه الحالة يتم نشر خيارات التعبير النمطي)، وقد لا يتم تحديد خيارات جديدة (منذ روبي 1.8).
 +
===[[Ruby/Regexp/quote | التابع quote]]===
 +
يُخلّص (escapes)  أي حرف قد يكون له معنى خاص في التعبير النمطي. ثم يُعيد سلسلة نصية جديدة مُخلّصة، أو يعيد الكائن  (self) إذا لم يتم تخليص أي أحرف.  لكل سلسلة نصية str، ستكون قيمة التعبير <code>Regexp.new(Regexp.escape( str ))=~ str</code> مساوية للقيمة true.
 +
===[[Ruby/Regexp/try_convert | التابع try_convert]]===
 +
يُحاول  تحويل الوسيط obj  إلى كائن من النوع <code>[[Ruby/Regexp|Regexp]]</code>، باستخدام التابع to_regexp. ثم يعيد التعبير النمطي الناتج، أو nil في حالة تعذر تحويل obj لسبب أو لآخر.
 +
===[[Ruby/Regexp/union | التابع union]]===
 +
يُعيد  كائن من النوع <code>Regexp</code>، والذي يمثل اتحاد الأنماط المعطاة، أي أنه سيتطابق مع أي من أجزائه. يمكن أن تكون الأنماط كائنات من النوع <code>[[Ruby/Regexp|Regexp]]</code>، وفي هذه الحالة سيتم الاحتفاظ بخياراتها، أو يمكن أن تكون سلاسل نصية. إذا لم يتم إعطاء أية أنماط، فسيعيد  القيمة <code>/(?!)/</code>. السلوك سيكون غير محدد إذا احتوى أيُّ من الأنماط المعطاة على التقاط (capture).
 +
===[[Ruby/Regexp/equality_operator | التابع ==]]===
 +
معامل التساوي - يتساوى تعبيران نمطيان إن كان نماطهما متطابقين، وكان لهما نفس رمز مجموعة الحروف (character set code)، وكانت لهمنا نفس قيمة <code>[[Ruby/Regexp/casefold-3F|casefold?‎]]</code>.
 +
===[[Ruby/Regexp/case_equality | التابع ===]]===
 +
معامل تساوي الحالة (Case Equality) - يُستخدم في العبارات case.
 +
===[[Ruby/Regexp/3D~ | التابع =~]]===
 +
يبحث  عن تطابق للتعبير النمطي rxp  ضمن str.
 +
===[[Ruby/Regexp/casefold-3F | التابع casefold?‎]]===
 +
يعيد  قيمة راية الحساسية لحالة الأحرف (case-insensitive flag).
 +
===[[Ruby/Regexp/encoding | التابع encoding]]===
 +
يُعيد  كائنًا من النوع <code>[[Ruby/Encoding|Encoding]]</code>، والذي يمثل ترميز الكائن .
 +
===[[Ruby/Regexp/eql-3F | التابع eql?‎]]===
 +
يعيد  القيمة true إن التعبير النمطي المعطى مساويًا للتعبير النمطي ، أي إن كان نمطاهما متطابقان، وكان لهما نفس رمز مجموعة الحروف (haracter set code)، وكانت لهما نفس قيمة <code>[[Ruby/Regexp/casefold-3F|casefold?‎]]</code>.
 +
===[[Ruby/Regexp/fixed_encoding-3F | التابع fixed_encoding?‎]]===
 +
يُعيد  القيمة false إن كان التعبير النمطي  قابلًا للتطبيق على سلسلة نصية ذات ترميز متوافق مع ASCII. أو يعيد true خلاف ذلك.
 +
===[[Ruby/Regexp/hash | التابع hash]]===
 +
يعيد  رمز تكويد (hash) استنادًا إلى نص وخيارات هذا التعبير النمطي.
 +
===[[Ruby/Regexp/inspect | التابع inspect]]===
 +
يعيد  نسخة نصية منسقة من التعبير النمطي . قد يكون من المفاجئ أن تعلم أن <code>#inspect</code> ينتج في الواقع نسخة طبيعية من السلسلة النصية أكثر حتى من التابع <code>#to_s</code>.
 +
===[[Ruby/Regexp/match | التابع match]]===
 +
يُعيد  كائنًا من النوع <code>MatchData</code> يصف المطابقة، أو يعيد <code>nil</code> إذا لم يكن هناك تطابق. هذا يُكافئ استرداد قيمة المتغير الخاص <code>$~</code> بعد مطابقة عادية. في حال تمرير الوسيط الثاني،، فإنه يحدد الموضع في السلسلة النصية لبدء البحث.
 +
===[[Ruby/Regexp/match-3F | التابع match?‎]]===
 +
يُعيد  القيمة <code>true</code> أو <code>false</code> بحسب ما إذا كان التعبير النمطي قد طوبِق أم لا دون تحديث المتغير $~ والمتغيرات الأخرى ذات الصلة. في حال إعطاء الوسيط الثاني، فإنّه يحدد الموضع في السلسلة النصية لبدء البحث.
 +
===[[Ruby/Regexp/named_captures | التابع named_captures]]===
 +
يُعيد  قاموسًا (hash) يحتوي معلومات حول الالتقاطات المسماة (named captures) لتتعبير النمطي .
 +
===[[Ruby/Regexp/names | التابع names]]===
 +
يعيد  قائمة بأسماء الأجزاء المُلتقطة (captures) على هبئة مصفوفة من سلاسل نصية.
 +
===[[Ruby/Regexp/options | التابع options]]===
 +
يُعيد مجموعة البتات (bits) المقابلة للخيارات المستخدمة عند إنشاء الكائن <code>[[Ruby/Regexp|Regexp]]</code> (انظر صفحة <code>Regexp::new</code> لمزيد من التفاصيل. لاحظ أنه قد يتم وضع بتات إضافية في الخيارات المُعادة: والتي تُستخدم داخليًا بواسطة في التعبير النمطي. يتم تجاهل هذه البتات الإضافية إذا تم تمرير الخيارات إلى <code>Regexp::new</code>.
 +
===[[Ruby/Regexp/source | التابع source]]===
 +
يعيد  السلسلة النصية الأصلية للنمط.
 +
===[[Ruby/Regexp/to_s | التابع to_s]]===
 +
يُعيد  سلسلة نصية تحتوي على التعبير النمطي وخياراته (باستخدام الصياغة <code>(?opts:source)</code>). يمكن إعطاء هذه السلسلة النصية مرة أخرى إلى المُنشئ <code>Regexp::new</code> لإنشاء تعبير نمطي مشابه للتعبير النمطي الأصلي. (لكن مع ذلك، قد لا يعيد المعامل <code>Regexp#==</code> القيمة trueعند مقارنتهما، حيث قد يختلف مصدر التعبير النمطي نفسه، كما يظهر المثال).  ينتج التابع <code>Regexp#inspect</code> نسخة ذات مقروئية أفضل بشكل عام للتعبير النمطي.
 +
===[[Ruby/Regexp/~ | التابع ~]]===
 +
يبحث  عن مطابقة التعبير النمطي  في محتويات المتغير <code>$_</code>. وهو مُكافئ للتعبير <code>rxp  =~ $_</code>.
 +
*[http://ruby-doc.org/core-2.5.1/Regexp.html قسم  الصنف Regexp في توثيق روبي الرسمي.]

مراجعة 11:23، 1 نوفمبر 2018

كائنات الصنف Regexp التعابير النمطية، والتي تُستخدم لمطابقة نمط (pattern) معيّن في سلسلة نصية. يتم إنشاء التعابير النمطية باستخدام الصياغتين /.../ و ‎%r{...}‎، أو بالمنشئ new.

التعابير النمطية هي أنماط تصف محتويات السلسلة النصية. يمكن استخدامها للتحقق من أنّ سلسلة نصية تحتوي على نمط معين، أو لاستخراج الأجزاء المُطابقة. يتم إنشاؤها باستخدام الصياغتين /pat/ و ‎%r{pat}‎، أو باستخدام المنشئ new.

عادة ما يتم تحديد التعبير النمطي بعارضة مائلة للأمام (/). كمل يوضح المثال أدناه:

/hay/ =~ 'haystack'   #=> 0
/y/.match('haystack') #=> #<MatchData "y">
‎

إذا احتوت سلسلة نصية على النمط فسيقال أنها مُطابقة، أو تتطابق مع التعبير النمطي. كل سلسلة نصية حرفية (literal) تطابق نفسها. في المثال الموالي، السلسلة النصية 'haystack' لا تحتوي على النمط 'needle'، لذلك فهي لا تتطابق:

/needle/.match('haystack') #=> nil
‎

أماا في هذا المثال، فالسلسلة النصية 'haystack' تحتوي على النمط 'hay'، لذلك فهي تتطابق:

/hay/.match('haystack')    #=> #<MatchData "hay">
‎

بشكل أكثر تحديدًا، يتطلب التعبير النمطي /st/ أن تحتوي السلسلة النصية على الحرف s متبوعاً بالحرف t ، لذلك فهي تتطابق مع "haystack" أيضًا.

المعامل ‎=~ ‎و التابع match

يمكن التحقق من مطابقة النمط باستخدام المعامل ‎=~‎ أو التابع match.

المعامل ‎=~‎

‎=~‎ هو معامل المُطابقة الأساسي في روبي. عندما يكون أحد معامليه عبارة عن تعبير نمطي، والآخر عبارة عن سلسلة نصية، فسيُستخدم التعبير النمطي حينها كنمط لمطابقة السلسلة النصية. (تعريف هذا المعامل في الصنفين Regexp و String متماثل، لذا لا يهم ترتيب السلسلة النصية أو التعبيرالنمطي لا يهم. قد يكون للأصناف الأخرى تقديمات (implementations) مختلفة للمعامل ‎=~‎.) في حالة العثور على تطابق، فسيعيد المعامل فهرس المطابقة الأولى في السلسلة النصية، وإلا فسيعيد nil.

/hay/ =~ 'haystack'   #=> 0
'haystack' =~ /hay/   #=> 0
/a/   =~ 'haystack'   #=> 1
/u/   =~ 'haystack'   #=> nil

عند استخدام المعامل ‎=~‎ مع كائن من النوع String أو Regexp، سيتم تعيين المتغير العام ‎$~‎ بعد الحصول على مطابقة ناجحة. سيحتوي المتغير ‎‎‎‎‎$~‎‎‎ على كائن من النوع MatchData.

التابعlast_match مكافئ للمتغير ‎$~‎.

التابع match

يعيد التابع match كائنًا من النوع MatchData:

/st/.match('haystack')   #=> #<MatchData "st">

الحروف الخاصة (Metacharacters) وحروف التخليص (Escapes)

الحروف التالية هي حروف خاصة (metacharacters):

( و ) و [ و ] و { و } و . و ? و + و *. لهذه الحروف معاني محددة عندما تظهر في تعبير نمطي. لمطابقتها حرفياً، يجب أن تكون مسبوقة بعارضة مائلة للخلف \. لمطابقة العارضة المائلة للخلف حرفياً، يجب أن تكون مسبوقة كذلك بعارضة مائلة للخلف: \\

/1 \+ 2 = 3\?/.match('Does 1 + 2 = 3?') #=> #<MatchData "1 + 2 = 3?">
/a\\\\b/.match('a\\\\b')                    #=> #<MatchData "a\\b">
‎

تتصرف الأنماط مثل السلاسل النصية المُقتبسة (double-quoted) بحيث يمكن أن تحتوي على نفس الشرطة المائلة للخلف المخصصة لأجل التخليص (backslash escapes).

/\s\u{6771 4eac 90fd}/.match("Go to 東京都")
    #=> #<MatchData " 東京都">
‎

يمكن تضمين تعابير روبي في الأنماط عبر الصياغة ‎#{...}‎.

place = "東京都"
/#{place}/.match("Go to 東京都")
    #=> #<MatchData "東京都">
‎

مجموعات الحروف (Character Classes)

يتم تحديد مجموعات الحروف (character class) بواسطة الأقواس المربعة ([ ، ]) وتوضع بينها الأحرف التي قد تظهر عند هذه النقطة في المطابقة. التعبير النمطي /[ab]/ يعني إما a أو b، على خلاف /ab/ الذي يعني الحرف a متبوعاً بالحرف b.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

ضمن مجموعات الحروف، تمثل الشرطة (-) حرفًا خاصا يشير إلى مجال شامل (inclusive) مكون من أحرف. التعبير النمطي [abcd] يكافئ [a-d]. يمكن أن يُتبع المجال بمجال آخر، لذلك فالتعبير النمطي [abcdwxyz] يكافئ [a-dw-z]. ولا يهم الترتيب الذي تظهر به المجالات أو الأحرف الفردية داخل مجموعة الحروف.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f')     #=> #<MatchData "9">

إذا كان أول حرف من حروف المجموعة هو العلامة (^)، فستُعكس المجموعة: أي أنها ستطابق أي حرف باستثناء تلك المحددة في المجموعة.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

يمكن أن تحتوي مجموعة حروف على مجموعة حروف أخرى. الشكل ‎[a-z[0-9]]‎ يصف نفس المجموعة [a-z0-9]. كما أنّ مجموعات الحروف تدعم المعامل && الذي يجري عملية التقاطع على وسائطه. ويمكن دمج الاثنين كما يلي:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))

هذا يُكافئ:

/[abh-w]/

تتصرف الحروف الخاصة (metacharacters) التالية مثل مجموعات الحروف:

  • /./ - أي حرف باستثناء محرف السطر الجديد.
  • ‎/./m - أي حرف (المُعدِّل m يتيح الوضع متعدد الأسطر)
  • ‎/\w/‎ - حرف كلمة ([a-zA-Z0-9_‎])
  • ‎‎‎‎‎/\W/‎ - ُحرف يخالف حروف الكلمة ([‎^a-zA-Z0-9_‎‎]). يرجى إلقاء نظرة على صفحة الخطأ Bug#4044 في حالة استخدام ‎‎‎‎‎/\W/‎ مع المُعدِّل ‎/i‎.
  • ‎/\d/‎ - حرف رقمي ([‎0-9])
  • ‎/\D/‎ - حرف غير رقمي ([‎^0-9])
  • ‎/\h/ ‎- حرف ستة عشري ([‎0-9a-fA-F])
  • ‎/\H/‎ - حرف غير ستة عشري ([‎^0-9a-fA-F])
  • ‎/\s/‎ - حرف من حروف المسافات البيضاء: /[‎ \t\r\n\f\v]/
  • ‎/\S/‎ - حرف يخالف حروف المسافة البيضاء: /[‎^‎ \t\r\n\f\v]/

تعبيرات أقواس POSIX ‏(POSIX bracket expressions) مشابهة لمجموعات الحروف. إذ توفر بديلاً محمولًا (portable) لما سبق، مع ميزة إضافية تتمثل في أنها يمكن أن تحتوي على أحرف من خارج الترميز ASCII. على سبيل المثال، لا يطابق التعبير ‏‏‎/\d/‎‏ إلا الأرقام العشرية للترميز ASCII ‏(0-9)؛ بينما يطابق التعبير /[[:digit:]]/ أي حرف من مجموعة الحروف العددية Nd في اليونيكود (Unicode Nd).

  • /[[:alnum:]]/- حرف أبجدي أو رقم
  • /[[:alpha:]]/ - حرف أبجدي
  • /[[:blank:]]/ - فراغ أو علامة تبويب (tab)
  • /[[:cntrl:]]/ - حرف تحكم (Control character)
  • /[[:digit:]]/ - رقم
  • /[[:graph:]]/ - حرف غير فارغ (يستثني المسافات وأحرف التحكم وما شابه)
  • /[[:lower:]]/ - الأحرف الأبجدية الصغيرة
  • /[[:print:]]/ - مثل [:graph:]، ولكنها تتضمن حرف المسافة
  • /[[:punct:]]/ - علامة ترقيم (Punctuation character)
  • /[[:space:]]/ - محرف مسافة بيضاء ([:blank:] أو سطر جديد أو حرف الرجوع [carriage return]، وما إلى ذلك)
  • /[[:upper:]]/ - حرف أبجدي كبير
  • /[[:xdigit:]]/ - رقم من الأرقام المسموح بها في الأعداد السداسي عشرية (أي الحروف ‎0-9a-fA-F)

تدعم روبي أيضًا مجموعات الحروف التالية بجانب مجموعات POSIX:

  • /[[:word:]]/ - حرف من إحدى مجموعات حروف اليونيكود العامة التالية Letter و Mark و Number و Connector_Punctuation.
  • /[[:ascii:]]/ - حرف من مجموعة حروف ASCII.
# U+06F2 is "EXTENDED ARABIC-INDIC DIGIT TWO"
/[[:digit:]]/.match("\u06F2")    #=> #<MatchData "\u{06F2}">
/[[:upper:]][[:lower:]]/.match("Hello") #=> #<MatchData "He">
/[[:xdigit:]][[:xdigit:]]/.match("A6")  #=> #<MatchData "A6">

التكرار

تتطابق التركيبات الموصوفة حتى الآن مع حرف واحد، لكن ماذا لو أردنا مطابقة أكثر من حرف دفعة واحدة. يمكننا ذلك باستخدام حروف خاصة تُسمى المُكممات (quantifiers). والتي توضع بعد الحرف الذي نريد أن يتكرر لتحديد عدد مرات ظهوره، هذه المكممات هي:

  • * - صفر مرّة أو أكثر.
  • + - مرة واحدة أو أكثر
  • ? - صفر مرة أو مرة واحدة (اختياري)
  • {n} - بالضبط n مرة
  • {n,} - على الأقل أكثر n مرة
  • {,m} - على الأكثر m مرة
  • {n,m} - بين n و m مرة

'مثال': على الأقل حرف كبير واحد ('H')، ثم حرف واحد صغير على الأقل ('e')، ثم حرفين 'l'، ثم حرف 'o':

"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

أنماط التكرار طمّاعة (greedy) افتراضيًا: أي أنها تبحث عن مطابقة أكبر جزء ممكن يحقق المطابقة من السلسلة النصية. على خلاف، فإن المطابقة القانعة (lazy matching) تكتفي بالحد الأدنى من السلسلة النصية الذي يحقق المطابقة بشكل عام.


يمكن جعل الحروف الخاصة الطماعة قانعة باتباعها بالحرف =~. كلا النمطين أدناه يتطابقان مع السلسلة النصية. يستخدم الأول مُكمما طماعًا، بحيث يطابق ". +" السلسة النصية "<a> " ؛ أما الثاني فيستخدم مكمما قانعا،بحيث يطابق '.+?'السلسلة النصية '<a>': المكممات المتبوعة بالعلامة + تُطابق تملكيًا (possessively): فبمجرد أن تُطابق لا يتراجع. تتصرف مثل المكممات الطماعة، ولكنها ترفض "التخلي" عن الأجزاء التي طابقتها حتى لو كان ذلك قد يُفشل كامل المطابقة. الالتقاط[aeiou]\w[aeiou]\w (?: يمكن استخدام الأقواس لأجل الالتقاط (capturing). يمكن لاحقًا التأشير إلى النص المتضمن في مجموعة الأقواس بالعدد n. داخل النمط استخدم ) ؛ أما خارج النمط فاستخدم \2. في المثال أدناه، يتم التقاط السلسلة النصية "at" بواسطة الزوج الأول من الأقواس، ثم يشار إليها لاحقًا باستخدام


‎</syntaxhighlight> يعيد التابع #match كائنًا من النوع MatchData والذ يجعل النص الذي تم التقاطه متاحًا عبر معامل الفهرسة []: 

/[csh](..) [csh]\1 in/.match("The cat sat in the hat")[1] #=> 'at'
‎

يمكن أن الرجوع إلى المجموعات الملتقطة باسمها في حال تعريف بالصياغة (?<name>) أو (?'name'). 

/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")
   #=> #<MatchData "$3.67" dollars:"3" cents:"67">
/\$(?<dollars>\d+)\.(?<cents>\d+)/.match("$3.67")[:dollars] #=> "3"
‎

يمكن الرجوع إلى المجموعات المُسماة بواسطة \k<name>، حيث name هو اسم المجموعة. 

/(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
   #=> #<MatchData "ototo" vowel:"o">
‎

ملاحظة: لا يمكن للتعبير النمطي استخدام المراجع المسماة (named backreferences) والمراجع الرقمية (numbered backreferences) في وقت واحد. عند استخدام مجموعات الالتقاط المسماة (named capture groups) مع تعبير نمطي حرفي على الجانب الأيسر من التعبير والمعامل =~، فستم تخزين النص الذي تم التقاطه في متغيرات محلية تحمل أسماء مشابهة. 

/\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ "$3.67" #=> 0
dollars #=> "3"
‎

التجميع ↑ تُجمّع الأقواس أيضًا التعابير التي تُطوّقها، مما يسمح بتحديدها كمجموعة واحدة. يتطابق النمط أدناه مع حرف متحرك (vowel) متبوعًا بحرفي كلمة (word characters): 

/[aeiou]\w{2}/.match("Caenorhabditis elegans") #=> #<MatchData "aen">
‎

بينما يتطابق النمط التالي مع حرف متحرك يتبعه حرف كلمة، مرتين ، مثل [aeiou]\w[aeiou]\w: "enor". 

/([aeiou]\w){2}/.match("Caenorhabditis elegans")
   #=> #<MatchData "enor" 1:"or">
‎

يوفر التعبير (?: إمكانية التجميع ) لكن بدون التقاط. وهذا يعني، أنه يُجمّع التعابير التي يحتوي عليها في وحدة غير قابلة للتجزيئ دون إنشاء مرجع إليه (backreference). هذا يفيد في تحسين الأداء على حساب إضرار طفيف بقابلية القراءة. الزوج الأول من الأقواس يلتقط "n"، أما الثاني فيلتقط "ti". تتم الإشارة إلى المجموعة الثانية لاحقًا باستخدام المرجع \2: 

/I(n)ves(ti)ga\2ons/.match("Investigations")
   #=> #<MatchData "Investigations" 1:"n" 2:"ti">
‎

لقط أصبح الزوج الأول من الأقواس غير قابل للالتقاط بسبب استخدام "؟:"، لذلك قسيتطابق مع "n"، ولكنه لن ينشئ مرجعًا إليه. وبالتالي ، فالمرجع \1 يشير الآن إلى "ti". 

/I(?:n)ves(ti)ga\1ons/.match("Investigations")
   #=> #<MatchData "Investigations" 1:"ti">
‎

↑ التجميع الذري يمكن جعل التجميعات ذرية بواسطة (?>pat). هذا سيؤدي إلى مطابقة التعبير الجزئي (subexpression) بشكل مستقل عن بقية التعبير، بحيث أنّ ما يطابقه سيصبح ثابتًا لبقية المطابقة، ما لم يتم التخلي عن التعبير الجزئي بأكمله وإعادة النظر فيه لاحقًا. بهذه الطريقة، يعامل pat باعتبارها وحدة غير قابلة للتجزيئ. يتم استخدام التجميع الذري عادة لتحسين أداء الأنماط، وكذلك لمنع إنشاء مراجع (backtracking) بدون داعٍ. يتطابق " في النمط أدناه مع الحرف الأول من السلسلة النصية، ثم يُطابق .* علامة التنصيص ". يؤدي هذا إلى فشل المطابقة الإجمالية، وهكذا فالنص المطابق لـ .* يحدد مرجعه (backtracked) بموضع واحد ، مما يتيح الحرف النهائي للسلسلة النصية لأجل لمطابقة " 

/".*"/.match('"Quote"')     #=> #<MatchData "\"Quote\"">
‎

إذا تم تجميع .* ذريًا، فسيرفض إنشاء مرجع للعلامة "، على الرغم من أن هذا سيعني أن المطابقة الإجمالية ستفشل 

/"(?>.*)"/.match('"Quote"') #=> nil
‎

استدعاء التعابير الجزئية ↑ تطابق الصياغة \g<name> التعبير الجزئي السابق المسمى name، والذي يمكن أن يكون اسم مجموعة أو رقم. هذا يختلف عن التأشير في أنه يعيد تنفيذ المجموعة بدلاً من مجرد محاولة إعادة مطابقة نفس النص. يتطابق النمط الموالي مع حرف (حرف ويُحيلها إلى المجموعة paren، ويحاول استدعاء التعبير الجزئ للمجموعة paren مرة أخرى لكنه يفشل، ثم يطابق محرفا [literal]): 

/\A(?<paren>\(\g<paren>*\))*\z/ =~ '()'
/\A(?<paren>\(\g<paren>*\))*\z/ =~ '(())' #=> 0
# ^1
#      ^2
#           ^3
#                 ^4
#      ^5
#           ^6
#                      ^7
#                       ^8
#                       ^9
#                           ^10
‎
  • يطابق بداية السلسلة النصية، أي قبل الحرف الأول. *يدخل مجموعة التقاط مسماة تسمى paren *يطابق المحرف (، الحرف الأول في السلسلة النصية *يستدعي المجموعة paren مرة أخرى، أي يعاود الرجوع (recurses) مرة أخرى إلى الخطوة الثانية *يعيد الدخول إلى المجموعة paren *يطابق المحرف (، الحرف الثاني في السلسلة النصية *يحاول استدعاء paren للمرة الثالثة، ولكن يفشله، لأن ذلك من شأنه أن يمنع مطابقة ناجحة شاملة *يطابق المحرف )، أي الحرف الثالث في السلسلة النصية. يحدد نهاية الاستدعاء العودي (recursive) الثانية *يطابق المحرف )، الحرف الرابع في السلسلة النصية *يطابق نهاية السلسلة النصية البدائل ↑ يُؤلّف الحرف الخاص (|) بين تعبيرين في تعبير واحد يطابق أيًا من تلك التعبيرات. كل تعبير هو بديل ممكن.
/\w(and|or)\w/.match("Feliformia") #=> #<MatchData "form" 1:"or">
/\w(and|or)\w/.match("furandi")    #=> #<MatchData "randi" 1:"and">
/\w(and|or)\w/.match("dissemblance") #=> nil
‎

خاصيات الحروف ↑ تُطابق الصياغة \p{} الحروف ذات الخاصية المحددة، مثل مجموعات أقواس POSIX. */\p{Alnum}/ - حرف أبجدي أو رقمي */\p{Alpha}/ - حرف أبجدي */\p{Blank}/ - مسافة بيضاء أو علامة تبويب (tab) */\p{Cntrl}/ - حرف تحكم */\p{Digit}/ - رقم */\p{Graph}/ - حرف غير فارغ (يستثني المسافات البيضاء وأحرف تحكم وما شابه) */\p{Lower}/ - حرف أبجدي صغير */\p{Print}/ - مثل \p{Graph} ، ولكنه يتضمن المسافة البيضاء */\p{Punct}/ - علامة ترقيم */\p{Space}/ - حرف مسافة بيضاء ([:blank:] أو سطر جديد أو حرف يُعيد[carriage return]، إلخ) */\p{Upper}/ - حرف أبجدي كبير */\p{XDigit}/ - رقم من الأرقام المسموح بها في الأعداد السداسي عشرية (على سبيل المثال ، 0-9a-fA-F) */\p{Word}/ - عنصر من إحدى مجموعات اليونيكود العامة التالية Letter، Mark، Number، Connector_Punctuation */\p{ASCII}/ - حرف من حروف ASCII. */\p{Any}/ - أي حرف من حروف اليونيكود (بما في ذلك الأحرف غير المعينة[unassigned]). */\p{Assigned}/ - حرف معين (assigned character). يمكن أيضًا مطابقة حرف من مجموعة اليونيكود General Category بالنمط \p{Ab} حيث Ab يمثل اختصار المجموعة كما هو موضح أدناه: /\p{L}/ - 'Letter' /\p{Ll}/ - 'Letter: Lowercase' /\p{Lm}/ - 'Letter: Mark' /\p{Lo}/ - 'Letter: Other' /\p{Lt}/ - 'Letter: Titlecase' /\p{Lu}/ - 'Letter: Uppercase /\p{Lo}/ -' Letter: Other '/\p{M}/ -' Mark '/\p{Mn}/ -' Mark: Nonspacing '/\p{Mc}/ -' Mark : Spacing Combining '/\p{Me}/ -' Mark: Enclosing '/\p{N}/ -' Number '/\p{Nd}/ -' Number: Decimal Digit '/\p{Nl}/ -' Number: Letter '/\p{No}/ -' Number: Other '/\p{P}/ -' Punctuation '/\p{Pc}/ -' Punctuation: Connector ' /\p{Pd}/ - 'Punctuation: Dash' /\p{Ps}/ - 'Punctuation: Open' /\p{Pe}/ - 'Punctuation: Close' XX XXX - 'علامات الترقيم: اقتباس أولي' /\p{Pi}/ - 'علامات الترقيم: اقتباس نهائي' /\p{Pf}/ - 'علامات الترقيم: أخرى' /\p{Po}/ - 'Symbol' /\p{S}/ - 'الرمز: Math' /\p{Sm}/ - 'الرمز: Currency' /\p{Sc}/ - 'Symbol: Currency' /\p{Sc}/ - 'Symbol: Modifier' /\p{Sk}/ - 'Symbol: Other' /\p{So}/ - 'Separator' /\p{Z}/ - 'Separator: Space' /\p{Zs}/ - 'Separator: Line' /\p{Zl}/ - 'Separator: Paragraph' /\p{Zp}/ - 'Other' /\p{C}/ - 'Other: Control '/\p{Cc}/ -' Other: Format '/\p{Cf}/ -' Other: Not Assigned '/\p{Cn}/ -' Other: Private Use '/\p{Co}/ -' Other: Surrogate 'Lastly، /\p{Cs}/ match for Unicode script. النصوص التالية مدعومة: العربية ، الأرمنية ، البالية ، البنغالية ، Bopomofo ، Braille ، Buginese ، Buhid ، Canadian_Aboriginal ، Carian ، Cham ، Cherokee ، Common ، Coptic ، المسمارية ، Cypriot ، السيريلية ، Deseret ، Devanagari ، الاثيوبية ، الجورجية ، Glagolitic ، القوطية ، اليونانية ، الغوجاراتية ، Gurmukhi ، هان ، هانغول ، Hanunoo ، العبرية ، الهيراجانا ، ورثت ، الكانادا ، Katakana ، Kayah_Li ، Kharoshthi ، الخمير ، لاو ، اللاتينية ، Lepcha ، Limbu ، Linear_B ، Lycian ، Lydian ، المالايالامية ، المنغولية ، ميانمار ، New_Tai_Lue، Nko، Ogham، Ol_Chiki، Old_Italic، Old_Persian، Oriya، Osmanya، Phags_Pa، Phoenician، Rejang، Runic، Saurashtra، Shavian، Sinhala، Sundanese، Syloti_Nagri، Syriac، Tagalog، Tagbanwa، Tai_Le، Tamil، Telugu، Thaana، Thai، التبتية ، تيفيناغ ، الأوغاريتية ، فاي ، ويي. محرفق اليونيكود U+06E9 يُسمى "ARABIC PLACE of SAJDAH" (موضع سجدة)، وينتمي إلى الخط العربي: \p{} يمكن عكس جميع خصائص الأحرف عن طريق إضافة البادئة ( 

/\p{Arabic}/.match("\u06E9") #=> #<MatchData "\u06E9">
‎

) إلى أسمائها. الحرف "A" ليس مُتضمّنًا في مجموعة اليونيكود Ll [تعني (Letter; Lowercase)]، لذلك تنجح المطابقة التالية: ^ 

/\p{^Ll}/.match("A") #=> #<MatchData "A">
‎

Anchors المراسي (Anchors) هي حروف خاصة تُطابق مواضع معدومة الطول بين الأحرف، وتربط المطابقة بموضع معين. *↑ - تطابق بداية السطر *^ - تطابق نهاية السطر *$ - تطابق بداية السلسلة النصية. *\A - تطابق نهاية السلسلة النصية. إذا انتهت السلسلة النصية بسطر جديد، فستُطابق الموضع الموجود قبل السطر الجديد مباشرة *\Z - تطابق نهاية السلسلة النصية \z - تطابق أول موضع مطابقة: في توابع مثل \G و String#gsub، تتغير عند كل تكرار. تتطابق في البداية مع بداية الموضوع، وفي كل تكرار تطابق مكان انتهاء المطابقة الأخيرة. String#scan في التوابع التي تأخذ موضعًا(اختياريًا)، مثل 

"    a b c".gsub(/ /, '_')    #=> "____a_b_c"
"    a b c".gsub(/\G /, '_')  #=> "____a b c"
‎

و Regexp#match، ستُطابق مكان بدء البحث. String#match * 

"hello, world".match(/,/, 3)    #=> #<MatchData ",">
"hello, world".match(/\G,/, 3)  #=> nil
‎

- تطابق مواضع حدود الكلمات عندما تكون خارج الأقواس؛ وتطابق محرف التراجع backspace (0x08) عندما تكون داخل الأقواس *\b - تُطابق المواضع المخالفة لحدود الكلمات *\Bpat(?= - المطالعة الأمامية الإيجابية (Positive lookahead assertion): تضمن أنّ الأحرف التالية تتطابق مع pat، ولكن لا تتضمن تلك الأحرف في النص المُطابق *)pat(?! - المطالعة الأمامية السلبية (Negative lookahead assertion): تضمن أنّ الأحرف التالية لا تتطابق مع pat، ولكن لا تتضمن تلك الأحرف في النص المُطابق *)pat(?<= -المطالعة الخلفية الإيجابية (Positive lookbehind assertion): تضمن تطابق الأحرف السابقة مع pat، ولكنها لا تتضمّن تلك الأحرف في النص المُطابق *)pat(?<! - المطالعة الخلفية الإيجابية (Negative lookbehind assertion): تضمن أنّ الأحرف السابقة لا تتطابق مع pat، ولكنها لا تتضمن تلك الأحرف في النص المُطابق إذا لم يتم وضع مرساة (anchored) للنمط، فيمكنه أن يبدأ من أي نقطة في السلسلة النصية: ) إرساء النمط عند بداية السلسلة النصية يفرض بدء المطابقة هناك. في المثال الآتي، لا تظهر "real" في بداية السلسلة النصية، لذلك تفشل المطابقة: 

/real/.match("surrealist") #=> #<MatchData "real">
‎

تفشل المطابقة أدناه لأنه على الرغم من أن "Demand" تحتوي "and" ، فإنّ النمط لا يظهر عند حدود الكلمات. 

/\Areal/.match("surrealist") #=> nil
‎

في حين أنّه في المثال التالي السلسلة النصية "and" تم إرساؤها عند الحدود غير الكلِمية، لذلك، فبدلاً من مطابقة "and" الأولى، فستتطابق مع الحرف الرابع من "demand" بدلاً من ذلك: 

/\band/.match("Demand")
‎

يستخدم النمط التالي المطالعة الأمامية الإيجابية و االمطالعة الخلفية الإيجابية لمطابقة النص الوارد في الوسوم (tags) دون تضمين الوسوم في المطابقة: 

/\Band.+/.match("Supply and demand curve") #=> #<MatchData "and curve">
‎

الخيارات 

/(?<=<b>)\w+(?=<\/b>)/.match("Fortune favours the <b>bold</b>")
   #=> #<MatchData "bold">
‎

يمكن أن يتبع محدد النهاية للتعبير النمطي بحرف واحد أو أكثر تمثل الخيارات التي تتحكم في كيفية مطابقة النمط. *↑ - Ignore case */pat/i - تجعل . تطابق محرف السطر الجديد /pat/m *. - تتجاهل المسافات البيضاء والتعليقات الموجودة في النمط */pat/x - تنفّذ عملية الاستكمال /pat/o مرة واحدة فقط يمكن أيضًا تطبيق #{} وi و m على مستوى التعابير الجزئية عبر الصياغة xon(?off-، والتي تفعّل الخيارات on، وتعطّل الخيارات off في التعبير المحاط بالأقواس. ) كما يمكن استخدام الخيارات مع 

/a(?i:b)c/.match('aBc') #=> #<MatchData "aBc">
/a(?i:b)c/.match('abc') #=> #<MatchData "abc">
‎
Regexp.new وضع التباعد الحر و تعليقات
Regexp.new("abc", Regexp::IGNORECASE)                     #=> /abc/i
Regexp.new("abc", Regexp::MULTILINE)                      #=> /abc/m
Regexp.new("abc # Comment", Regexp::EXTENDED)             #=> /abc # Comment/x
Regexp.new("abc", Regexp::IGNORECASE | Regexp::MULTILINE) #=> /abc/mi
‎

كما ذُكر أعلاه، يتيح الخيار ↑ وضع التباعد الحر. يتم تجاهل محارف المسافاة البيضاء داخل النمط، ويقدم محرف الشباك octothorpe (x) تعليقًا حتى نهاية السطر. يسمح هذا بتنظيم مكونات النمط بطريقة تجعله أكثر مقروئية. في المثال التالي يطابق النمط عددًا مع منازل عشرية اختيارية: # هناك عدة استراتيجيات لمطابقة المسافات البيضاء: *استخدم نمطًا مثل 

float_pat = /\A
   [[:digit:]]+ # 1 or more digits before the decimal point
   (\.          # Decimal point
       [[:digit:]]+ # 1 or more digits after the decimal point
   )? # The decimal point and following digits are optional
\Z/x
float_pat.match('3.14') #=> #<MatchData "3.14" 1:".14">
‎

أو \s. *استخدم مسافات بيضاء مُخلّصة (escaped whitespace) مثل \p{Space}، أي مسافة مسبوقة بخط مائل عكسي. *استخدم مجموعة حروف مثل \. يمكن تضمين التعليقات في انماط غير النمط [ ] باستخدام الصياغة xcomment(?#، حيث أن التعليق نص اعتباطي يتم تجاهله من محرك التعبير النمطي. لا يمكن أن تتضمن التعليقات المُتضمّنة في تعبير نمطي حرفي محرف إنهاء غير مُخلص (unescaped terminator characters). )Encoding يفترض أن تستخدام التعابير النمطية ترميز المصدر. يمكن تجاوز هذا بأحد المُعدِّلات التالية. ↑pat/ - UTF-8 /upat/ - EUC-JP /epat/ - Windows-31J /spat/ - ASCII-8BIT يمكن مطابقة تعبير نمطي مع سلسلة نصية عندما يتشاركان في الترميز، أو إن كان ترميز التعبير النمطي هو US-ASCII وترميز السلسلة النصية متوافق مع ASCII. إذا تمت محاولة المطابقة بين ترميزات غير متوافقة، فسيُطلق الاستثناء /n. تتحقق الدالة المنطقية Encoding::CompatibilityError مما إذا كان للتعبير النمطي ترميز ثابت، ومتوافق مع الترميز ASCII. يمكن تثبيت ترميز التعبير النمطي بشكل صريح عبر تمرير Regexp#fixed_encoding? كوسيط ثانٍ للتابع Regexp::FIXEDENCODING: Regexp.new متغيرات عامة مخصوصة 

r = Regexp.new("a".force_encoding("iso-8859-1"),Regexp::FIXEDENCODING)
r =~ "a\u3042"
  # raises Encoding::CompatibilityError: incompatible encoding regexp match
  #         (ISO-8859-1 regexp with UTF-8 string)
‎

من المهم معرفة بعض المتغيرات العامة: * تكافئ ↑؛ *$~ تحتوي كامل النص المتطابق؛ *::last_match تحتوي السلسلة النصية التي تسبق التطابق؛ *$& تحتوي السلسلة النصية التي تعقب التطابق؛ *$` و $' وهلم جرًا، تحتوي النص المُتطابق مع مجموعة الالتقاط الأولى، والثانية، وما إلى ذلك؛ *$1 تحتوي آخر مجموعة مُلتقطة. مثال: $2 هذه المتغيرات العامة هي متغيرات مخصوصة بالمهام الفرعية (thread-local)، ومخصوصة بالتوابع (method-local). الأداء $+ 

m = /s(\w{2}).*(c)/.match('haystack') #=> #<MatchData "stac" 1:"ta" 2:"c">
$~                                    #=> #<MatchData "stac" 1:"ta" 2:"c">
Regexp.last_match                     #=> #<MatchData "stac" 1:"ta" 2:"c">
$&      #=> "stac"
       # same as m[0]
$`      #=> "hay"
       # same as m.pre_match
$'      #=> "k"
       # same as m.post_match
$1      #=> "ta"
       # same as m[1]
$2      #=> "c"
       # same as m[2]
$3      #=> nil
       # no third group in pattern
$+      #=> "c"
       # same as m[-1]
‎

يمكن أن تؤدي بعض التوليفات غير السليمة في الصياغة إلى أداء سيئ جدا. انظر المثال التالي: تتم مطابقة الأنماط التالية على الفور كما هو متوقع: ↑ أما النمط التالي فيستغرق وقتًا أطول بشكل ملحوظ: 

s = 'a' * 25 + 'd' + 'a' * 4 + 'c'
#=> "aaaaaaaaaaaaaaaaaaaaaaaaadaaaac"
‎

يحدث هذا لأن ذرة في التعبير النمطي مٌكمّمة (quantified) بواسطة كل من الحرف 

/(b|a)/ =~ s #=> 0
/(b|a+)/ =~ s #=> 0
/(b|a+)*/ =~ s #=> 0
‎

والحرف 

/(b|a+)*c/ =~ s #=> 26
‎

بدون تحديد لمن منهما سيكون التحكم لرحف معين. عدم الوضوح ينتج عنه ينتج أداء خطي فائق (super-linear performance). (راجع Mastering Regular Expressions (3rd ed.)، pp 222 ، بواسطة Jeffery Friedl ، لإجراء تحليل متعمق). يمكن إصلاح هذه المشكلة عن طريق استخدام التجميع الذري، والذي يمنع التأشير غير الضروري: + يوضح المثال التالي حالة مشابهة، والتي استغرقت حوالي 60 ثانية للتنفيذ عندي: مطابقة سلسلة نصية مكونة 29 حرف "a" مقابل نمط مؤلف من 29 حرف "a" اختياري يليه 29 إلزاميًا على النحو التالي: * حروف "a" التسعة وعشرون الاختيارية تطابق السلسلة النصية، لكن هذا يمنع الحروف التسعة وعشروت الإلزامية الموالية من المطابقة. تتراجع روبي مرارًا وتكرارًا حتى تستوفي أكبر عدد ممكن من التطابقات الاختيارية دون التفريط في المطابقة التسعة وعشرين الإجبارية. من الواضح لنا أنه لا يمكن لأي من المطابقات الاختيارية أن تنجح، ولكن هذه الحقيقة ليست واضحة للأسف لروبي. أفضل طريقة لتحسين الأداء هي تقليل مقدار التراجع المطلوب إلى أقصى حد. في هذه الحالة، بدلاً من المطابقة الفردية لـ 29 حرفًا اختياريًا، يمكن مطابقة مجال اختياريً دفعة واحدة عبر {0،29}: 

(start = Time.now) && /(b|a+)*c/ =~ s && (Time.now - start)
  #=> 24.702736882
(start = Time.now) && /(?>b|a+)*c/ =~ s && (Time.now - start)
  #=> 0.000166571
‎


توابع الصنف العامة (Public Class Methods)

التابع compile

اسم آخر للتابع Regexp.new

التابع escape

يُخلّص (Escapes) أي حرف يمكن أن يكون له معنى خاص في التعبير النمطي. ثم يعيد سلسلة نصية جديدة مُخلّصة، أو يعيد الكائن (self) في حال عدم تخليص أي أحرف. لكل سلسلة نصية str، ستكون قيمة Regexp.new(Regexp.escape( str ))=~ str مساوية للقيمة true.

التابع last_match

يُعيد في الشكل الأول كائن MatchData الذي تم إنشاؤه من آخر تطابق ناجح للنمط. وهو مكافئ لقراءة المتغير العام المخصوص $~ (راجع المتغيرات العامة المخصوصة في صفحة Regexp لمزيد من التفاصيل).

التابع new

ينشئ تعبيرًا نمطيًا جديدًا من pattern، والذي يمكن أن يكون إما سلسلة نصية (String) أو كائنًا من النوع Regexp (وفي هذه الحالة يتم نشر خيارات التعبير النمطي)، وقد لا يتم تحديد خيارات جديدة (منذ روبي 1.8).

التابع quote

يُخلّص (escapes) أي حرف قد يكون له معنى خاص في التعبير النمطي. ثم يُعيد سلسلة نصية جديدة مُخلّصة، أو يعيد الكائن (self) إذا لم يتم تخليص أي أحرف. لكل سلسلة نصية str، ستكون قيمة التعبير Regexp.new(Regexp.escape( str ))=~ str مساوية للقيمة true.

التابع try_convert

يُحاول تحويل الوسيط obj إلى كائن من النوع Regexp، باستخدام التابع to_regexp. ثم يعيد التعبير النمطي الناتج، أو nil في حالة تعذر تحويل obj لسبب أو لآخر.

التابع union

يُعيد كائن من النوع Regexp، والذي يمثل اتحاد الأنماط المعطاة، أي أنه سيتطابق مع أي من أجزائه. يمكن أن تكون الأنماط كائنات من النوع Regexp، وفي هذه الحالة سيتم الاحتفاظ بخياراتها، أو يمكن أن تكون سلاسل نصية. إذا لم يتم إعطاء أية أنماط، فسيعيد القيمة /(?!)/. السلوك سيكون غير محدد إذا احتوى أيُّ من الأنماط المعطاة على التقاط (capture).

التابع ==

معامل التساوي - يتساوى تعبيران نمطيان إن كان نماطهما متطابقين، وكان لهما نفس رمز مجموعة الحروف (character set code)، وكانت لهمنا نفس قيمة casefold?‎.

التابع ===

معامل تساوي الحالة (Case Equality) - يُستخدم في العبارات case.

التابع =~

يبحث عن تطابق للتعبير النمطي rxp ضمن str.

التابع casefold?‎

يعيد قيمة راية الحساسية لحالة الأحرف (case-insensitive flag).

التابع encoding

يُعيد كائنًا من النوع Encoding، والذي يمثل ترميز الكائن .

التابع eql?‎

يعيد القيمة true إن التعبير النمطي المعطى مساويًا للتعبير النمطي ، أي إن كان نمطاهما متطابقان، وكان لهما نفس رمز مجموعة الحروف (haracter set code)، وكانت لهما نفس قيمة casefold?‎.

التابع fixed_encoding?‎

يُعيد القيمة false إن كان التعبير النمطي قابلًا للتطبيق على سلسلة نصية ذات ترميز متوافق مع ASCII. أو يعيد true خلاف ذلك.

التابع hash

يعيد رمز تكويد (hash) استنادًا إلى نص وخيارات هذا التعبير النمطي.

التابع inspect

يعيد نسخة نصية منسقة من التعبير النمطي . قد يكون من المفاجئ أن تعلم أن #inspect ينتج في الواقع نسخة طبيعية من السلسلة النصية أكثر حتى من التابع #to_s.

التابع match

يُعيد كائنًا من النوع MatchData يصف المطابقة، أو يعيد nil إذا لم يكن هناك تطابق. هذا يُكافئ استرداد قيمة المتغير الخاص $~ بعد مطابقة عادية. في حال تمرير الوسيط الثاني،، فإنه يحدد الموضع في السلسلة النصية لبدء البحث.

التابع match?‎

يُعيد القيمة true أو false بحسب ما إذا كان التعبير النمطي قد طوبِق أم لا دون تحديث المتغير $~ والمتغيرات الأخرى ذات الصلة. في حال إعطاء الوسيط الثاني، فإنّه يحدد الموضع في السلسلة النصية لبدء البحث.

التابع named_captures

يُعيد قاموسًا (hash) يحتوي معلومات حول الالتقاطات المسماة (named captures) لتتعبير النمطي .

التابع names

يعيد قائمة بأسماء الأجزاء المُلتقطة (captures) على هبئة مصفوفة من سلاسل نصية.

التابع options

يُعيد مجموعة البتات (bits) المقابلة للخيارات المستخدمة عند إنشاء الكائن Regexp (انظر صفحة Regexp::new لمزيد من التفاصيل. لاحظ أنه قد يتم وضع بتات إضافية في الخيارات المُعادة: والتي تُستخدم داخليًا بواسطة في التعبير النمطي. يتم تجاهل هذه البتات الإضافية إذا تم تمرير الخيارات إلى Regexp::new.

التابع source

يعيد السلسلة النصية الأصلية للنمط.

التابع to_s

يُعيد سلسلة نصية تحتوي على التعبير النمطي وخياراته (باستخدام الصياغة (?opts:source)). يمكن إعطاء هذه السلسلة النصية مرة أخرى إلى المُنشئ Regexp::new لإنشاء تعبير نمطي مشابه للتعبير النمطي الأصلي. (لكن مع ذلك، قد لا يعيد المعامل Regexp#== القيمة trueعند مقارنتهما، حيث قد يختلف مصدر التعبير النمطي نفسه، كما يظهر المثال). ينتج التابع Regexp#inspect نسخة ذات مقروئية أفضل بشكل عام للتعبير النمطي.

التابع ~

يبحث عن مطابقة التعبير النمطي في محتويات المتغير $_. وهو مُكافئ للتعبير rxp =~ $_.

مجلوبة من "https://wiki.hsoub.com/index.php?title=Ruby/Regexp&oldid=22059"