ביטויים רגילים

הפונקציות IsMatch, Match ו- MatchAll משמשות לחילוץ ואימות דפוסים בטקסט. התבנית בה הם משתמשים נקראת **ביטוי רגולרי**. ...

ביטויים רגולריים הם רבי עוצמה ורב-תכליתיים. עם זאת, לעיתים הם יכולים להופיע כרצף אקראי של סימני פיסוק. מאמר זה אינו מתאר את כל ההיבטים של ביטויים רגולריים, אך שפע של מידע, מדריכים וכלים זמינים באינטרנט.

לביטויים רגולריים יש היסטוריה ארוכה והם זמינים בשפות תכנות רבות. לכל שפת תכנות יש ניב משלה של ביטויים רגולריים, וישנם מעט סטנדרטים. ככל האפשר, אנו שואפים שאותו ביטוי רגולרי ייתן את אותה תוצאה בכל ה- Power Fx המימושים. תאימות אינה קלה להשגה מכיוון שהיא פועלת על גבי JavaScript ו-.NET, שביניהם הבדלים משמעותיים. Power Fx כדי לפעול בפלטפורמות שונות, Power Fx ביטויים רגולריים משתמשים בקבוצת משנה של תכונות הנתמכות באופן נרחב ברחבי התעשייה.

כתוצאה מכך, ייתכן שחלק מהביטויים הרגולריים שעובדים בסביבות אחרות ייחסמו או שיידרשו התאמות ב- Power Fx. שגיאות בזמן עריכה מדווחות כאשר נתקלים בתכונות שאינן נתמכות. זו הסיבה שהביטוי הרגולרי והאפשרויות חייבים להיות קבועי זמן של יצירת האובייקט ולא דינמיים, כמו למשל שהם מסופקים במשתנה.

הערה

Power Apps משתמש בגרסה מוקדמת יותר של **ביטויים רגולריים**, שיש לה פחות מגבלות אך גם פחות תכונות. Power Fx MatchOptions.DotAll ו- MatchOptions.FreeSpacing אינן זמינות וההגדרות של Match.Email ו- Match.Hyphen שונות. זוגות פונדקאיים ביוניקוד אינם מטופלים כתו יחיד. MatchOptions.NumberedSubMatches הוא ברירת המחדל. גרסת הביטויים הרגולריים המתוארת כאן תהיה זמינה בקרוב, תחת כפתור "תאימות V1.0". Power Apps Power Fx

תכונות נתמכות

Power Fx תומך בתכונות הביטוי הרגולרי הבאות, עם הערות כיצד Power Fx התנהגות עשויה להיות שונה ממערכות אחרות.

הביטוי הרגולרי חייב להיות קבוע ולא מחושב או מאוחסן במשתנה. האופרטור & , אינטרפולציה של מחרוזות $"{...}", והפונקציות Concatenate, Char ו- UniChar עם ארגומנטים קבועים נתמכים.

תווים מילוליים

תכונה	Description
תווים מילוליים	ניתן להכניס כל תו יוניקוד ישירות, למעט `\`, `[`, `]`, `^`, `$`, `.`, `\|`, `?`, ``, `+`, `(`, `)`, `{`, ו `}`. בעת שימוש בתווי רווח מסוג MatchOptions.FreeSpacing*, `#`, ותווי רווח `\s` אחרים, יש להשתמש בתווי Escape מכיוון שיש להם משמעות שונה.
תווים מילוליים שנמלטו	`\` (קו נטוי הפוך) ואחריו אחד מהתווים הליטרליים הישירים, כגון `\?` כדי להוסיף סימן שאלה. `\#` ו `\` ניתן להשתמש בו גם כאשר MatchOptions.FreeSpacing מושבת לשם עקביות.
קודי תווים הקסדצימליים ויוניקוד	`\x20` עם בדיוק שתי ספרות הקסדצימליות, `\u2028` עם בדיוק ארבע ספרות הקסדצימליות וניתן להשתמש בהן עבור פונדקאיות גבוהות ונמוכות.
נקודת קוד יוניקוד	`\u{01F47B}` עם עד שמונה ספרות הקסדצימליות. חייב להיות בטווח 0 עד U+10FFFF ולא ניתן להשתמש בו עבור פונדקאית גבוהה או נמוכה. עשוי לגרום לזוג חלופי (שני תווים) אם גדול מ-U+FFFF.
החזרת גררה	`\r`, אותו דבר כמו `Char(13)`.
תו שורה חדשה	`\n`, אותו דבר כמו `Char(10)`.
הזנת טופס	`\f`, אותו דבר כמו `Char(12)`.
לשונית אופקית	`\t`, אותו דבר כמו `Char(9)`.

השתמש ב \x או ב \u במקום זאת. קודים אוקטליים עבור תווים, כגון \044 או \o{044} אינם מותרים, מכיוון שהם עלולים להיות דו משמעיים עם הפניות ממוספרות לאחור.

\v אינו נתמך מכיוון שהוא דו משמעי בשפות ביטוי רגולרי. השתמש ב \x0b עבור טאב אנכי או [\x0b\f\r\n\x85\u2028\u2029] עבור רווח לבן אנכי.

טענות

קביעות תואמות למיקום מסוים בטקסט אך אינן צורכות תווים.

תכונה	Description
תחילת השורה	`^`, תואם לתחילת הטקסט, או של שורה אם נעשה שימוש ב- MatchOptions.Multiline .
סוף השורה	`$`, תואם לסוף הטקסט, או של שורה אם נעשה שימוש ב- MatchOptions.Multiline .
מבט קדימה	`(?=a)` ו `(?!a)`, תואם קדימה עבור דפוס.
מבט לאחור	`(?<=b)` ו- `(?<!b)`, תואם מאחור עבור תבנית.
מעברי מילים	`\b` ו `\B`, תוך שימוש בהגדרת יוניקוד לאותיות `[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]`.

$ תואם לסוף שורה, כולל כל שורה נגררת \r\n, \r או \n.

קביעות של "מבט קדימה" ו"מבט מאחור" לא יכולות להכיל תת-התאמות או כימות בלתי מוגבל בתוכן, ולא ניתן להשתמש בהן עם כימות חיצוני.

שיעורי דמויות

תכונה	Description
נְקוּדָה	`.`, תואם להכל מלבד `\r` ו- `\n` אלא אם כן נעשה שימוש ב- MatchOptions.DotAll .
מחלקת אופי	`[abc]` רשימת דמויות, `[a-fA-f0-9]` מגוון דמויות, `[^a-z]` הכל מלבד הדמויות האלה. לא ניתן לקנן, לחסר או לחתוך מחלקות תווים, וסימני פיסוק רבים עשויים שלא להופיע פעמיים ברצף (`@@`, `%%`, `!!` וכו').
תווי מילים	`\w` ו `\W` שימוש בהגדרת יוניקוד לאותיות `[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]`. `\W` לא ניתן להשתמש בו במחלקת תווים שלילית.
תווי ספרות	`\d` כולל את הספרות `0` עד`9` ו `\p{Nd}`, `\D` תואם להכל מלבד תווים שתואמים על ידי `\d`. `\D` לא ניתן להשתמש בו במחלקת תווים שלילית.
דמויות חלל	`\s` כולל תווי ריווח `[ \t\n\x0b\f\r\x85\u2028\u2029\p{Z}]`, `\S` אשר תואם את כל מה פרט לתווים שתואמים על ידי `\s`. `\S` לא ניתן להשתמש בו במחלקת תווים שלילית.
קטגוריית תווים ביוניקוד	`\p{Ll}` התאמה לכל האותיות הקטנות של יוניקוד, בעוד ש- `\P{Ll}` התאמה לכל מה שאינו אות קטנה של יוניקוד. `\P{}` לא ניתן להשתמש בו במחלקת תווים שלילית.

כדי להגביר את הבהירות ולמנוע עמימות, מחלקות תווים בסוגריים מרובעים מגבילות יותר מאשר בשפות ביטויים רגולריים אחרות:

יש להשתמש בתווים של מקף מילולי באותיות Escape. השתמש ב- [\-a] במקום [-a] כדי להתאים ל- - או ל- a.
יש להשתמש בסוגריים מרובעים בתחילתם באמצעות תווי Escape. השתמש ב- [\[a] במקום [[] כדי להתאים ל- [ או ל- a.
אלא אם כן זהו התו הראשון והוא מציין שלילה, יש להשתמש בתו Escape. השתמש ב- [a\^] במקום [a^] כדי להתאים ל- ^ או ל- a.
יש להימלט מגשרים מתולתלים. השתמש ב [\{\}] כדי להתאים { או }.
מחלקת תווים ריקה [] אינה נתמכת. כדי לכלול סוגר מרובע סוגר במחלקת תווים, יש להשתמש בפונקציה escape.

קטגוריות תווים ביוניקוד הנתמכות על ידי \p{} ו \P{}:

אותיות: L, Lu, Ll, Lt, Lm, Lo
סימנים: M, Mn, Mc, Me
מספרים: N, Nd, Nl, No
פיסוק: P, Pc, Pd, Ps, Pe, Pi, Pf, Po
סמלים: S, Sm, Sc, Sk, So
מפרידים: Z, Zs, Zl, Zp
בקרה ועיצוב: Cc, Cf, בעוד שקטגוריות קידומות C אחרות אינן נתמכות.

\Wלא ניתן להשתמש ב-, \D, \S ו- \P{} בתוך מחלקת תווים שנשללה [^...]. על מנת להיות מיושמים בפלטפורמות מסוימות, מחלקות תווים שליליים אלו מתורגמות למקבילותיהן ביוניקוד, דבר שעלול להיות קשה לביצוע אם גם הן מבוטלות.

תווי יוניקוד בין U+10000 ל-U+10FFFF, הדורשים זוגות חלופיים, אינם נתמכים במחלקות תווים.

כמותיים

תכונה	Description
אפס או אחד חמדנים	`?` התאמות אפס או פעם אחת, עם התאמה גדולה ככל האפשר.
אפס חמדן או יותר	`` תואמות אפס פעמים או יותר, עם התאמה גדולה* ככל האפשר.
חמדן אחד או יותר	`+` תואם פעם אחת או יותר, עם התאמה גדולה ככל האפשר.
חמדן לפחות n	`{n,}` התאמות לפחות n פעמים, עם התאמה גדולה ככל האפשר. לדוגמה, `a{3,}` תואם את כל התווים ב- `aaaaa`.
חמדן בין n ל-m	`{n,m}` התאמות בין n ל-m פעמים, עם התאמה גדולה ככל האפשר. לדוגמה, `a{1,3}` תואם לשלושת התווים הראשונים של `aaaaa`.
אפס או אחד עצלנים	`??` התאמות אפס או פעם אחת, עם התאמה קטנה ככל האפשר.
אפס עצל או יותר	`*?` התאמות אפס פעמים או יותר, עם התאמה קטנה ככל האפשר.
עצלן אחד או יותר	`+?` תואם פעם אחת או יותר, עם התאמה קטנה ככל האפשר.
עצלן לפחות n	`{n,}?` התאמות לפחות n פעמים, עם התאמה קטנה ככל האפשר. לדוגמה, `a{3,}?` תואם רק לשלושת התווים הראשונים ב- `aaaaa`.
עצלן בין n ל-m	`{n,m}?` התאמות בין n ל-m פעמים, עם התאמה קטנה ככל האפשר. לדוגמה, `a{1,3}?` תואם רק לתו הראשון של `aaaaa`.
N מדויק	`{n}` תואם n פעמים, בדיוק. לדוגמה, `a{3}` תואם בדיוק לשלושה תווים של `aaaaa`.

כמותיים רכושניים אינם נתמכים.

לערבוב של תת-התאמות וכימותים יש מגבלות. למידע נוסף, ראה התאמות תת-התאמות שעשויות להיות ריקות.

קבוצות

תכונה	Description
הוסף קבוצה	`(` ו- `)` משמשים לקיבוץ אלמנטים לצורך יישום כימותים. לדוגמה, `(abc)+` התאמות `abcabc`.
הִתחַלְפוּת	`a\|b` תואם ל-"a" או "b", המשמש לעתים קרובות בקבוצה.
תת-התאמה בשם והפניה חזרה	`(?<name>chars)` לוכד תת-התאמה עם השם `name`, שאליה מפנה `\k<name>`. לא ניתן להשתמש אם MatchOptions.NumberedSubMatches מופעל.
תת-התאמה ממוספרת והפניה חזרה	כאשר MatchOptions.NumberedSubMatches מופעל, `(a)` לוכד תת-התאמה אליה מפנה `\1`.
קבוצה שאינה נקלטה	`(?:a)`, יוצר קבוצה מבלי ללכוד את התוצאה כהתאמה משנה בעלת שם או ממוספרת. כל הקבוצות אינן ניתנות לליכידה אלא אם כן MatchOptions.NumberedSubMatches מופעל.

לא ניתן להשתמש יחד בתת-התאמות בעלות שם וממוספרות. כברירת מחדל, התאמות משנה בעלות שם מופעלות ועדיפות לשם בהירות ותחזוקה, בעוד שקבוצות לכידה סטנדרטיות הופכות לקבוצות שאינן לכידה עם ביצועים משופרים. ניתן לשנות התנהגות זו באמצעות MatchOptions.NumberedSubMatches המספק קבוצות לכידה מסורתיות אך מבטל קבוצות לכידה בעלות שם. חלק מהמימושים מתייחסים לשילוב של קבוצות לכידה ממוספרות ושמות באופן שונה, ולכן Power Fx אוסר זאת.

קבוצות לכידה בעלות הפניה עצמית אינן נתמכות, לדוגמה הביטוי הרגולרי (a\1).

שתי קבוצות לכידה אינן יכולות לשתף את אותו שם, לדוגמה, הביטוי הרגולרי (?<id>\w+)|(?<id>\d+) אינו נתמך.

שם של תת-התאמה בעלת שם חייב להתחיל בתו \p{L} או _, ויכול להמשיך עם תווים אלה בתוספת \p{Nd}. שמות מוגבלים באורך של 62 יחידות קוד UTF-16.

הפניות לאחור לתת-התאמות שעשויות להיות ריקות ולהתאמות לתת-התאמות בתוך מבט לאחור או מבט קדימה גם אינן נתמכות.

חלק מהיישומים מציעים אפשרות "לכידה מפורשת" לשיפור הביצועים, שאינה הכרחית מכיוון שזוהי ברירת המחדל. Power Fx MatchOptions.NumberedSubMatches מבטל אותו ומאפשר לכידות ממוספרות באופן מרומז.

לערבוב תת-התאמות וכימותים יש מגבלות. ראה התאמות משנה שעשויות להיות ריקות למידע נוסף.

הערות

תכונה	Description
הערות מוטבעות	`(?# comment here)`, אשר מתעלמים ממנו כהערה. התגובה מסתיימת בסוגריים הסוגרים הבאים, גם אם יש סוגריים פותחים בהערה.

ראה MatchOptions.FreeSpacing לקבלת חלופה לעיצוב והוספת הערות לביטויים רגולריים.

אפשרויות מוטבעות

תכונה	Description
אפשרויות מוטבעות	`(?im)` זהה לשימוש ב- MatchOptions.IgnoreCase ו- MatchOptions.Multiline. יש להגדיר זאת בתחילת הביטוי הרגולרי.

מצבי שיתוף נתמכים הם [imsx]. אלה תואמים ל- MatchOptions.IgnoreCase, MatchOptions.Multiline, MatchOptions.DotAll, ו- MatchOptions.FreeSpacing, בהתאמה. n מקובל גם לצורך תאימות אך אין לו השפעה מכיוון שזוהי ברירת המחדל ואינה תואמת ל- MatchOptions.NumberedSubMatches.

לא ניתן להשתמש באפשרויות מוטבעות כדי להשבית אפשרות או להגדיר אפשרות עבור ביטוי משנה.

אפשרויות

אפשרויות התאמה משנות את אופן הפעולה של התאמת ביטויים רגולריים. ישנן שתי דרכים להפעיל אפשרויות, שניתן לשלב ביניהן כל עוד אין התנגשות:

ערך הספירה של MatchOptions הועבר כארגומנט השלישי ל- Match, MatchAll, ו- IsMatch. ניתן לשלב אפשרויות עם האופרטור & או הפונקציה Concatenate , לדוגמה MatchOptions.DotAll & MatchOptions.FreeSpacing. כל פונקציות הביטוי הרגולרי דורשות ש- MatchOptions יהיה ערך קבוע, לא ניתן לחשב אותו או לאחסן אותו במשתנה.
(?...) קידומת ממש בתחילת הביטוי הרגולרי. ניתן לשלב אפשרויות עם מספר אותיות במבנה (?...) , לדוגמה (?sx). לחלק מהאפשרויות אין (?...) מקבילה, אך עשויות להיות להן דרכים אחרות להשיג את אותו האפקט, לדוגמה MatchOptions.BeginsWith הוא המקבילה ל- ^ בתחילת הביטוי הרגולרי.

מכיל

מופעל עם MatchOptions.Contains ללא טקסט שווה ערך לביטוי רגולרי. MatchOptions.Contains הוא ברירת המחדל עבור כל הפונקציות מחוץ ל- Power Apps; within Power Apps MatchOptions.Complete הוא ברירת המחדל עבור IsMatch.

מלא

מופעל באמצעות MatchOptions.Complete או השתמש ב- ^ וב- $ בתחילת הביטוי הרגולרי ובהתאמה.

BeginsWith

מופעל באמצעות MatchOptions.BeginsWith או השתמש ב ^ בתחילת הביטוי הרגולרי ובתחילתו.

EndsWith

מופעל באמצעות MatchOptions.EndsWith או השתמש ב $ בסוף הביטוי הרגולרי.

דוט אול

מופעל באמצעות MatchOptions.DotAll או (?s) בתחילת הביטוי הרגולרי.

בדרך כלל, אופרטור הנקודה . מתאים לכל התווים מלבד תווי שורה חדשה [\n\x0b\f\r\x85\u2028\u2029]. בעזרת הערך DotAll , כל התווים מותאמים, כולל שורות חדשות.

בדוגמה זו, רק ה-"Hello" תואם, שכן כברירת מחדל ה- . לא יתאים לשורה החדשה:

Trim( Match( "Hello
              World", ".*" ).FullMatch )
// returns 
// "Hello"

אבל אם נוסיף את המגדיר DotAll , אז השורה החדשה וכל התווים הבאים יתאימו:

Trim( Match( "Hello
              World", ".*", MatchOptions.DotAll ).FullMatch )
// returns 
// "Hello
// World"

מרווח חופשי

מופעל באמצעות MatchOptions.FreeSpacing או (?x) בתחילת ביטוי רגולרי.

ריווח חופשי מקל על קריאת ביטוי רגולרי מורכב ותחזוקה שלו. הכללים פשוטים:

תווי רווח מתעלמים מהם בביטוי הרגולרי, כולל כל התווים שיתאימו ל- \s. אם רוצים להתאים רווח, השתמשו ב- \s, \ , \t, \r או \n.
# מתחילה הערה שנמשכת עד סוף השורה. הוא וכל התווים הבאים עד לתו השורה החדשה הבא (תווים שלא תואמים על ידי . ללא MatchOptions.DotAll) מתעלמים מהם.
קבוצות דמויות אינן כלולות בשינויים אלה. רווחו תווים ו # פעלו כרגיל. לדוגמה, IsMatch( "a#b c", "(?x)a[ #]b[ #]c" ) מחזירה true. חלק משפות ביטויים רגולריים כוללות מחלקות תווים בריווח חופשי, או מספקות אפשרות לכלול אותן, אך Power Fx לא עושה זאת.

לדוגמה, הנה ביטוי רגולרי מורכב להתאמת תאריך ושעה לפי ISO 8601:

IsMatch( 
    "2025-01-17T19:38:49+0000",
    "^\d{4}-(0\d|1[012])-([012]\d|3[01])(T([01]\d|2[0123]):[0-5]\d(:[0-5]\d(\.\d{3})?)?(Z|[\-+]\d{4}))?$"
)
// returns true

והנה אותו ביטוי רגולרי זהה עם ריווח חופשי המשתמש בשורות מרובות, הזחה לקבוצות והערות לביטויים רגולריים, מה שהופך גרסה זו לקלה יותר להבנה, אימות ותחזוקה.

IsMatch( "2025-01-17T19:38:49+0000", 
    "(?x)                 # enables free spacing, must be very first
    ^                     # matches from beginning of text
    \d{4}                 # year (0000-9999)
    -(0\d|1[012])         # month (00-12)
    -([012]\d|3[01])      # day (00-31, range not checked against month)
    (T([01]\d|2[0123])    # optional time, starting with hours (00-23)
      :[0-5]\d            # minutes (00-59)
      (:[0-5]\d           # optional seconds (00-59)
        (\.\d{3})?        # optional milliseconds (000-999)
      )?
      (Z|[\-+]\d{4})      # time zone
    )?
    $                     # matches to end of text
    "
)
// returns true

התעלם/התעלם/התעלם/התעלמות ...

מופעל באמצעות MatchOptions.IgnoreCase או (?i) בתחילת ביטוי רגולרי.

התאמת טקסט באותיות גדולות ואינן תלויות בקטנות: אותיות גדולות תואמות לאותיות קטנות ואותיות קטנות תואמות לאותיות גדולות.

לדוגמה:

IsMatch( "HELLO!", "hello", MatchOptions.IgnoreCase )
// returns true

IsMatch( "file://c:/temp/info.txt", "^FILE://", MatchOptions.IgnoreCase )
// returns true

רוב החלקים או Power Fx בעלי מודעות תרבותית, אבל לא כאן. שימוש בהתאמה בלתי משתנה של תרבות הוא הסטנדרט בתעשייה עבור ביטויים רגולריים, כולל ב-JavaScript ו-Perl. זה שימושי בדוגמה השנייה שבה משאב מערכת נמצא בהתאמה, למשל, בתרבות tr-TR כאשר I אינו המקבילה באותיות גדולות של i.

אם נדרשת התאמה מודעת לתרבות ולא תלוית רישיות, השתמשו במחלקה characters עם התווים התואמים במקום זאת, לדוגמה [Hh][Ee][Ll][Ll][Oo] עבור הדוגמה הראשונה.

ריבוי שורות

מופעל באמצעות MatchOptions.Multiline או (?m) בתחילת ביטוי רגולרי.

בדרך כלל, עוגנים ^ ו- $ תואמים לתחילת טקסט הקלט ולתחילתו. בעזרת המגדיר Multiline , עוגנים אלה מתאימים לתחילת ולסוף השורות בטקסט הקלט, כאשר כל שורה מסתיימת ב- \r, \n, \r\n, או בסוף הקלט. לדוגמה:

MatchAll( "Hello" & Char(13) & Char(10) & "World", "^.+$" )
// returns 
// "Hello"

תבניות מוגדרות מראש

תבניות מוגדרות מראש מאפשרות לך להתאים תו אחד מקבוצת תווים או רצף של תווים מרובים. השתמש באופרטור string-concatenation & כדי לשלב את מחרוזות הטקסט שלך עם איברים ב- Match enum:

הספירה 'התאמה'	Description	ביטוי רגיל
כֹּל	מתאים לכל תו.	`.`
פְּסִיק	תואם פסיק `,`.	`,`
סִפְרָה	תואם ספרה בודדת (`0` עד `9` ואיברים אחרים של `\p{Nd}`).	`\d`
Email	תואם כתובת דוא"ל המכילה את הסימן "at" (`@`) ושם דומיין המכיל לפחות נקודה אחת (`.`), המופרדים על ידי רווח לבן ותווי פיסוק.	ראה הערה
מַקָף	מתאים למקף.	`-` ראה הערה
שמאלה	תואם לסוגריים שמאליים `(`.	`\(`
מִכְתָב	מתאים לאות.	`\p{L}`
מספר ספרות	מתאים לספרה אחת או יותר.	`\d+`
אותיות מרובות	מתאים לאות אחת או יותר.	`\p{L}+`
מספר לא-רווחים	מתאים לתו אחד או יותר שאינם מוסיפים רווח לבן (לא רווח, טאב או שורה חדשה).	`\S+`
מרחבים מרובים	מתאים לתו אחד או יותר שמוסיפים רווח לבן (רווח, טאב או שורה חדשה).	`\s+`
לא חלל	מתאים לתו יחיד שאינו מוסיף רווח לבן.	`\S`
ספרות אופציונליות	מתאים לאפס ספרות, ספרה אחת או יותר.	`\d*`
אותיות אופציונליות	מתאים לאפס אותיות, אות אחת או יותר.	`\p{L}*`
אופציונלילארווחים	מתאים לאפס תווים, תו אחד או יותר שלא מוסיפים רווח לבן.	`\S*`
מרחבים אופציונליים	מתאים לאפס תווים, תו אחד או יותר שמוסיפים רווח לבן.	`\s*`
תְקוּפָה	תואם נקודה או נקודה `.`.".	`\.`
הורה ימין	תואם לסוגריים ימני `)`.	`\)`
מֶרחָב	מתאים לתו שמוסיף רווח לבן.	`\s`
כרטיסיה	מתאים לתו טאב.	`\t`

לדוגמה, התבנית "A" ו-Match.MultipleDigits תואמת את האות "A" ואחריה ספרה אחת או יותר.

דפוס ה- Match.Email מורכב יותר מהשאר. הוא מזהה ומחלץ כתובות דוא"ל נפוצות בצורה local@hostname.tld, אולי מקטעי טקסט ארוכים, ותומך בתווים בינלאומיים ואמוג'יז. השתמש בו כדי לאמת טופס שמקבל כתובת דוא"ל כקלט, כבדיקה מהירה שהקלט נמצא בטופס דוא"ל. אם אינך מחלץ, השתמש בפונקציה MatchOptions.Complete כדי לזהות כתובת דוא"ל, לדוגמה, בבקרת קלט טקסט.

עם זאת, Match.Email אינו מאמת שכתובת הדוא"ל עומדת בכל הסטנדרטים הרבים והמתפתחים עבור כתובות דוא"ל, שמות דומיין ודומיינים ברמה העליונה, אשר ידרשו ביטוי רגולרי מסובך שיהיה צורך לעדכן אותו מעת לעת. למרות שרוב כתובות הדוא"ל מטופלות כצפוי, Match.Email תואם לחלק מהאותיות הגדולות והלא חוקיות, כגון קו תחתון בשם המארח, ואינו תואם לחלק מהאותיות הגדולות והתקפות, כגון כתובות דוא"ל במירכאות או כתובות IP. במידת הצורך, ישנם ביטויים רגולריים רבים באינטרנט לזיהוי כתובת דוא"ל חוקית באמת. תמיד בדקו את הביטוי הרגולרי שלכם בהתאם לצרכים הספציפיים שלכם לפני השימוש בו בסביבת ייצור.

אם ברצונך לראות את הביטוי הרגולרי שבו נעשה שימוש, הערך את הנוסחה Text( Match.Email ). החלק הראשון תואם את התווים שלפני @ ואינו כולל סימני פיסוק נפוצים של ASCII בהתאם ל- RFC 822 ולתיקונים ולסימני הפיסוק המתחילים והסוגרים לפי Unicode, כמו (, [, “, « ו- 「. הוא אינו תומך בשימוש הלא שכיח והלא מומלץ במחרוזות או הערות במירכאות. לאחר ה- @, החלקים השני והשלישי של הביטוי הרגולרי זהים ומופרדים על ידי ., מה שמבטיח שתמיד יהיה לפחות . אחד בכתובת. חלקים אלה אינם כוללים את כל סימני הפיסוק של Unicode למעט ., - ו- _. כתובות IP אינן נתמכות. בכל כתובת הדוא"ל, תווים בינלאומיים וסימני אמוג'י נתמכים.

ב- Power Apps, כאשר לא משתמשים ב- Power Fx 1.0, ל- Match.Email ול- Match.Hyphen יש הגדרות שונות במקצת. Match.Email היא פשוטה יותר, אך אינה מתאימה לחילוץ כתובת דוא"ל מכיוון שהיא לוכדת רווחים. בעבר, Match.Hyphen בוצעה חיפוש מחוץ למחלקת תווים, וכעת היא אינה חוקית.

התאמות משנה ממוספרות

מופעל עם MatchOptions.NumberedSubMatches ללא אפשרות מוטבעת. (?n) נתמך כהיפך מאפשרות זו לצורך תאימות והוא ברירת המחדל.

כברירת מחדל, (...) לא לוכד, המקבילה למה שרוב המערכות מכנות "לכידה מפורשת". כדי ללכוד, השתמש בלכידה בעלת שם עם (?<name>...) עם backreference \k<name>. שימוש בלכידות בעלות שם משפר את הביצועים בכך שהוא לא לוכד קבוצות שאינן נחוצות, משפר את הבהירות על ידי שימוש בשמות, ומפחית את הנטייה לשגיאות אם מיקום הלכידות משתנה.

אם יש לך ביטוי רגולרי קיים, ייתכן שהוא תלוי בלכידת קבוצות אוטומטית וממוספרות, כולל הפניות ממוספרות לאחור. התנהגות זו זמינה באמצעות האפשרות MatchOptions.NumberedSubMatches .

לא ניתן להשתמש יחד בתת-התאמות בעלות שם וממוספרות. מכיוון שחלק מהיישומים מתייחסים לתערובת של קבוצות לכידה ממוספרות ושמות באופן שונה, Power Fx הפעולה אינה מתירה זאת.

התאמות משנה ריקות אולי

כפי שצוין במבוא, ביטויים רגולריים של Power Fx מוגבלים במכוון לתכונות שניתן ליישם באופן עקבי במנועי ביטויים רגולריים בשפות תכנות אחרות. שגיאות בזמן הכתיבה מונעות שימוש בתכונות שאינן חלק מקבוצה זו.

תחום אחד שיכול להיות שונה בין יישומים הוא אופן הטיפול בתת-התאמות ריקות. לדוגמה, חשבו על הביטוי הרגולרי (?<submatch>a*)+ שנדרש להתאים לטקסט a. ב-.NET, התאמת המשנה גורמת למחרוזת טקסט ריקה, בעוד שב-JavaScript היא גורמת ל- a. ניתן לטעון ששניהם נחשבים למימושים נכונים, שכן ניתן לספק את ה + כמת עם מחרוזת ריקה מכיוון שלתוכן הקבוצה יש * כמת.

כדי להימנע מתוצאות שונות בין יישומים שונים, לא ניתן להשתמש בתת-התאמות שעשויות להיות ריקות עם כימות. Power Fx הנה דוגמאות כיצד תת-התאמה יכולה להיות ריקה:

דוגמאות	Description
`(?<submatch>a{0,}b*)+`	כל התוכן של תת-התאמת הוא אופציונלי, כך שכל תת-התאמת עשויה להיות ריקה.
`((<submatch>a)?b)+`	בגלל ה `?` מחוץ להתאמה המשנית, התאמה המשנית כולה היא אופציונלית.
`(?<submatch>a\|b*)+`	חילוף בתוך תת-ההתאמה עם משהו שיכול להיות ריק עלולה לגרום לכך שכל תת-ההתאמה תהיה ריקה.
`((?<submatch>a)\|b)+`	חלופה מחוץ לתת-התאמת יכולה להתאים `b` ובמקרה זה תת-התאמת תהיה ריקה.

התאמת המשנה ב- (?<submatch>a+)+ לא יכולה להיות ריקה מכיוון שחייבת להיות לפחות a אחת בהתאמת המשנה, והיא נתמכת.

Unicode

Power Fx ביטויים רגולריים משתמשים בקטגוריות יוניקוד כדי להגדיר \w, \d ו- \s, כאשר קטגוריות ספציפיות זמינות דרך \p{..}.

הגדרות אלו עשויות להשתנות בין פלטפורמות. לדוגמה, תקן יוניקוד מתעדכן מעת לעת בתווים חדשים אשר בהמשך יוטמעו על ידי פלטפורמות בקצב שלהן. צפו לשינויים בתוצאות בין פלטפורמות עד שכל הפלטפורמות יעודכנו.

Power Fx ביטויים רגולריים מבטיחים שמידע על קטגוריות זמין תמיד עבור המישור הרב-לשוני הבסיסי (תווים U+0 עד U+ffff). חלק מהפלטפורמות אינן מיישמות קטגוריות עבור תווים במישור הרב-לשוני המשלים ומעבר לו (U+10000 עד U+10ffff). מגבלה זו בדרך כלל אינה מהווה דאגה מכיוון שתווים במישור הרב-לשוני הבסיסי הם הנפוצים ביותר. השתמשו בערכי תווים ישירות במקום בקטגוריות אם התרחיש שלכם כולל תווים ב-U+10000 ומעלה. בדקו את הביטויים הרגולריים שלכם בפלטפורמות בהן אתם מתכוונים להשתמש.

ייתכן שקיימים הבדלים קטנים במקרי קצה בין פלטפורמות. לדוגמה, ייתכן שחלק מהפלטפורמות לא יראו ſ כתואם s כאשר MatchOptions.IgnoreCase מופעל. אם תווים אלה חשובים לתרחיש שלך, השתמש במחלקת תווים כמו [ſsS] כדי להתאים באופן שאינו רגיש לרישיות ולכלול במפורש את התווים הרצויים.

משוב

האם הדף הזה היה מועיל?

Last updated on 2025-07-29