RegEx: 20 צעדים קצרים לשליטה בביטויים רגולריים. חלק 3

RegEx: 20 צעדים קצרים לשליטה בביטויים רגולריים. חלק 1. RegEx: 20 צעדים קצרים לשליטה בביטויים רגולריים. חלק 2: בחלק זה נעבור לדברים קצת יותר מורכבים. אבל לשלוט בהם, כמו קודם, לא יהיה קשה. אני חוזר על כך ש-RegEx הוא למעשה קל יותר ממה שזה נראה בהתחלה, ואתה לא צריך להיות מדען טילים כדי לשלוט בו ולהתחיל להשתמש בו בפועל. המקור האנגלי של מאמר זה נמצא כאן .

שלב 11: סוגריים ()כקבוצות לכידה

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

תבנית: ([AZ])|([az]) 
מחרוזת:   הנשיא הנוכחי של בוליביה הוא אבו מוראלס .
תואמים: ^^^ ^^^^^^^ ^^^^^^^^^^ ^^ ^^^^^^^ ^^ ^^^ ^^^^^^^ 
קבוצה:    122 2222222 122222222 22 1222222 22 122 1222222  

( דוגמה ) הביטוי הרגולרי שלמעלה מגדיר שתי קבוצות לכידה המופיעות באינדקס החל מ-1. קבוצת הלכידה הראשונה מתאימה לכל אות גדולה בודדת, וקבוצת הלכידה השנייה מתאימה לכל אות קטנה בודדת. על ידי שימוש בסימן 'או' |ובסוגריים ()כקבוצת לכידה, נוכל להגדיר ביטוי רגולרי יחיד המתאים לסוגים מרובים של מחרוזות. אם נחיל את זה על הרקס החיפוש הארוך/צף שלנו מהחלק הקודם של המאמר, אז מנוע ה-Regex יתפוס את ההתאמות המתאימות בקבוצות המתאימות. על ידי בדיקה לאיזו קבוצה מתאימה מחרוזת משנה, נוכל לקבוע מיד אם זה ערך צף או ערך ארוך:

תבנית: (\d*\.\d+[fF]|\d+\.\d*[fF]|\d+[fF])|(\d+[lL]) 
מחרוזת:   42L 12 x 3.4f 6l 3.3 0F LF .2F 0.
התאמות: ^^^ ^^^^ ^^ ^^ ^^^ 
קבוצה:    222 1111 22 11 111  

( דוגמה ) הביטוי הרגולרי הזה מורכב למדי, וכדי להבין אותו טוב יותר, בואו נפרט אותו ונסתכל על כל אחת מהדפוסים הבאים:

( // מתאים לכל תת מחרוזת "צף".
  \d*\.\d+[fF]
  |
  \d+\.\d*[fF]
  |
  \d+[fF]
)
| //אוֹ
( // מתאים לכל תת מחרוזת "ארוכה".
  \d+[lL]
)

הסימן |וקבוצות הלכידה בסוגריים ()מאפשרים לנו להתאים סוגים שונים של מחרוזות משנה. במקרה זה, אנו מתאימים מספרי נקודה צפה "צפים" או מספרים שלמים ארוכים "ארוכים".

(
  \d*\.\d+[fF] // 1+ ספרות מימין לנקודה העשרונית
  |
  \d+\.\d*[fF] // 1+ ספרות משמאל לנקודה העשרונית
  |
  \d+[fF] // ללא נקודה, רק 1+ ספרות
)
|
(
  \d+[lL] // ללא נקודה, רק 1+ ספרות
)

בקבוצת הלכידה "צף" יש לנו שלוש אפשרויות: מספרים עם לפחות ספרה אחת מימין לנקודה העשרונית, מספרים עם ספרה אחת לפחות משמאל לנקודה העשרונית ומספרים ללא נקודה עשרונית. כל אחד מהם הוא "צף" כל עוד יש לו את האותיות "f" או "F" המצורפות לסוף. בתוך קבוצת הלכידה ה"ארוכה", יש לנו רק אפשרות אחת - חייבת להיות לנו ספרה אחת או יותר ואחריה התו "l" או "L". מנוע הביטוי הרגולרי יחפש מחרוזות משנה אלו במחרוזת נתונה ויוסיף אותן לאינדקס בקבוצת לכידה המתאימה. הערהשאנחנו לא מתאימים לאף אחד מהמספרים שלא נוספו להם "l", "L", "f" או "F". כיצד יש לסווג את המספרים הללו? ובכן, אם יש להם נקודה עשרונית, ברירת המחדל של שפת Java היא "כפולה". אחרת הם חייבים להיות "int".

בואו נאחד את מה שלמדנו עם כמה חידות:

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

תבנית:
מחרוזת:   42L 12 x 3.4f 6l 3.3 0F LF .2F 0. 
תואמים: ^^^ ^^ ^^^^ ^^ ^^^ ^^ ^^^ ^^ 
קבוצה:    333 44 1111 33 222 11 111 22

( פתרון ) הבעיה הבאה היא קצת יותר פשוטה. השתמש בקבוצות לכידה בסוגריים (), בסימן 'או' |ובטווחי תווים כדי למיין את הגילאים הבאים: "חוקי לשתות בארה"ב". (>= 21) ו"אסור לשתות בארה"ב" (<21):

תבנית:
מחרוזת:   7 10 17 18 19 20 21 22 23 24 30 40 100 120 
התאמות: ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ 
קבוצה:    2 22 22 22 22 22 11 11 11 11 11 11 111 111 

( פתרון )

שלב 12: זהה תחילה התאמות ספציפיות יותר

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

תבנית: ([AZ][az]?[az]?)|([AZ][az][az][az]+) 
מחרוזת:   Kim Job s Xu Clo yd Moh r Ngo Roc k.
התאמות: ^^^ ^^^ ^^ ^^^ ^^^ ^^^ ^^^ 
קבוצה:    111 111 11 111 111 111 111   

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

תבנית: ([AZ][az][az][az]+)|([AZ][az]?[az]?) 
מחרוזת:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
תואמים: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
קבוצה:    222 1111 22 11111 1111 222 1111    

( דוגמא )

משימה... הפעם רק אחת :)

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

תבנית:
מחרוזת:   pds6f uub 24r2gp ewqrty l ui_op 
תואמים: ^^^^^ ^^^ ^^^^^^ ^^^^^^ ^ ^^^^^ 
קבוצה:    NNNNN VVV NNNNNN VVVVVV N VVVVV

( פתרון ) באופן כללי, ככל שהביטוי הרגולרי שלך מדויק יותר, כך הוא יסתיים זמן רב יותר. וככל שזה מדויק יותר, כך יקטן הסיכוי שתלכוד משהו שאתה לא צריך. אז למרות שהם עשויים להיראות מפחידים, קבצים רגסיים ארוכים יותר ~= קבצים רגסיים טובים יותר. לצערי .

שלב 13: פלטה מתולתלת {}למספר מסוים של חזרות

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

תבנית: ([AZ][az][az][az]+)|([AZ][az]?[az]?) 
מחרוזת:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
תואמים: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
קבוצה:    222 1111 22 11111 1111 222 1111    

עבור הקבוצה הראשונה, היינו צריכים שמות משפחה עם ארבע אותיות או יותר. הקבוצה השנייה נאלצה ללכוד שמות משפחה עם שלוש או פחות אותיות. האם יש דרך קלה יותר לכתוב את זה מאשר לחזור על [a-z]הקבוצות האלה שוב ושוב? קיים אם אתה משתמש בפלטה מתולתלת בשביל זה {}. סוגרים מסולסלים {}מאפשרים לנו לציין את מספר ההתאמות המינימלי ו(אופציונלי) המקסימלי של הדמות או קבוצת הלכידה הקודמת. ישנם שלושה מקרי שימוש {}:

{X} // תואם בדיוק X פעמים
{X,} // מתאים >= X פעמים
{X,Y} // תואם >= X ו-<= Y פעמים

להלן דוגמאות לשלושת התחבירים השונים הללו:

תבנית: [az]{11} 
מחרוזת:   humuhumunuk unukuapua'a.
תואם: ^^^^^^^^^^^   

( דוגמא )

תבנית: [az]{18,} 
מחרוזת:   humuhumunukunukuapua 'a.
תואם: ^^^^^^^^^^^^^^^^^^^^^    

( דוגמא )

תבנית: [az]{11,18} 
מחרוזת:   humuhumunukunukuap ua'a.
תואם: ^^^^^^^^^^^^^^^^^^^    

( דוגמה ) יש לציין מספר נקודות בדוגמאות לעיל.הערה:. ראשית, באמצעות סימון {X}, התו או הקבוצה הקודמים יתאימו בדיוק למספר הזה (X) פעמים. אם יש יותר תווים ב"מילה" (מהמספר X) שיכולים להתאים לתבנית (כפי שמוצג בדוגמה הראשונה), אז הם לא ייכללו בהתאמה. אם מספר התווים קטן מ-X, ההתאמה המלאה תיכשל (נסה לשנות 11 ל-99 בדוגמה הראשונה). שנית, הסימונים {X,} ו-{X,Y} הם חמדנים. הם ינסו להתאים כמה שיותר דמויות תוך כדי סיפוק הביטוי הרגולרי הנתון. אם תציין {3,7}, ניתן להתאים בין 3 ל-7 תווים ואם 7 התווים הבאים תקפים, כל 7 התווים יותאמו. אם תציין {1,} וכל 14,000 התווים הבאים תואמים, אז כל 14,000 התווים הללו ייכללו במחרוזת המתאימה. כיצד נוכל להשתמש בידע הזה כדי לשכתב את הביטוי שלנו למעלה? השיפור הפשוט ביותר עשוי להיות החלפת הקבוצות השכנות [a-z]ב- [a-z]{N}, כאשר N נבחר בהתאם:

תבנית: ([AZ][az]{2}[az]+)|([AZ][az]?[az]?)  

...אבל זה לא הופך את המצב להרבה יותר טוב. תסתכל על קבוצת הלכידה הראשונה: יש לנו [a-z]{2}(שמתאימה בדיוק ל-2 אותיות קטנות) ואחריה [a-z]+(שמתאימה לאותיות קטנות אחת או יותר). אנו יכולים לפשט זאת על ידי בקשה של 3 אותיות קטנות או יותר באמצעות סוגרים מסולסלים:

תבנית: ([AZ][az]{3,})|([AZ][az]?[az]?) 

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

תבנית: ([AZ][az]{3,})|([AZ][az]{0,2}) 

הספציפיות תמיד טובה יותר כשמשתמשים בביטויים רגולריים, אז זה יהיה חכם לעצור שם, אבל אני לא יכול שלא לשים לב ששני טווחי התווים האלה ( [AZ]ו [az]) זה ליד זה נראים כמעט כמו מחלקה של "תו מילה", \w( [A-Za-z0-9_]) . אם היינו בטוחים שהנתונים שלנו מכילים רק שמות משפחה מעוצבים היטב, אז נוכל לפשט את הביטוי הרגולרי שלנו ולכתוב בפשטות:

תבנית: (\w{4,})|(\w{1,3}) 

הקבוצה הראשונה לוכדת כל רצף של 4 או יותר "תווי מילה" ( [A-Za-z0-9_]), והקבוצה השנייה לוכדת כל רצף מ-1 עד 3 "תווי מילה" (כולל). זה יעבוד?

תבנית: (\w{4,})|(\w{1,3}) 
מחרוזת:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
תואמים: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
קבוצה:    222 1111 22 11111 1111 222 1111    

( דוגמה ) זה עבד! מה דעתך על הגישה הזו? וזה הרבה יותר נקי מהדוגמה הקודמת שלנו. מכיוון שקבוצת הלכידה הראשונה מתאימה לכל שמות המשפחה עם ארבעה או יותר תווים, נוכל אפילו לשנות את קבוצת הלכידה השנייה לפשוטה \w+, מכיוון שהדבר יאפשר לנו ללכוד את כל שמות המשפחה הנותרים (עם 1, 2 או 3 תווים):

תבנית: (\w{4,})|(\w+) 
מחרוזת:   Kim Jobs Xu Cloyd Mohr Ngo Rock .
תואמים: ^^^ ^^^^ ^^ ^^^^^ ^^^^ ^^^ ^^^^ 
קבוצה:    222 1111 22 11111 1111 222 1111    

( דוגמא )

בואו נעזור למוח ללמוד זאת ולפתור את 2 הבעיות הבאות:

השתמש בסוגרים מסולסלים {}כדי לשכתב את הביטוי הרגולרי של חיפוש מספר תעודת זהות משלב 7:

תבנית:
מחרוזת: 113-25=1902 182-82-0192 H23-_3-9982 1I1-O0-E38B
תואם:              ^^^^^^^^^^^

( פתרון ) נניח שבודק חוזק הסיסמאות של אתר אינטרנט דורש שסיסמאות משתמש יהיו בין 6 ל-12 תווים. כתוב ביטוי רגולרי המסמן את הסיסמאות הלא חוקיות ברשימה למטה. כל סיסמה כלולה בסוגריים ()לצורך התאמה קלה, לכן ודא שהביטוי הרגולרי מתחיל ומסתיים בתווים מילוליים (וסמליים ). רמז: ודא שאתה לא מתיר סוגריים מילוליים בסיסמאות עם [^()]או דומות, אחרת בסופו של דבר תתאים לכל המחרוזת!

תבנית:
מחרוזת:   (12345) (הסיסמה שלי) (Xanadu.2112) (su_do) (OfSalesmen!)
תואם: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^  

( פתרון )

שלב 14: \bסמל גבול אפס רוחב

המשימה האחרונה הייתה די קשה. אבל מה אם נעשה את זה קצת יותר מסובך על ידי הוספת סיסמאות במרכאות ""במקום בסוגריים ()? האם נוכל לכתוב פתרון דומה פשוט על ידי החלפת כל התווים בסוגריים במרכאות?

pattern: \"[^"]{0.5}\"|\"[^"]+\s[^"]*\" 
string:   "12345" "הסיסמה שלי" "Xanadu.2112 " " su_do" " OfSalesmen! "
תואם: ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^  

( דוגמה ) זה לא יצא מרשים במיוחד. כבר ניחשתם למה? הבעיה היא שאנחנו מחפשים כאן סיסמאות שגויות. "Xanadu.2112" היא סיסמה טובה, כך שכאשר הביטוי הרגולרי מבין שהרצף הזה אינו מכיל רווחים או תווים מילוליים ", הוא מתקבל ממש לפני התו "שמכשיר את הסיסמה בצד ימין. (מכיוון שציינו "שלא ניתן למצוא תווים בתוך סיסמאות באמצעות [^"].) ברגע שמנוע הביטויים הרגולריים משוכנע שהתווים הללו אינם תואמים לביטוי רגולרי מסוים, הוא פועל שוב, בדיוק היכן שהפסיק - היכן היה התו ". מה שמגביל " Xanadu.2112" מימין. משם הוא רואה תו רווח אחד, ועוד תו "- מבחינתו זו הסיסמה הלא נכונה! בעצם, הוא מוצא את הרצף הזה " "וממשיך הלאה. זה בכלל לא מה שהיינו רוצים לקבל... זה יהיה נהדר אם נוכל לציין שהתו הראשון של הסיסמה לא צריך להיות רווח. האם יש דרך לעשות זאת? (עד עכשיו בטח כבר הבנת שהתשובה לכל השאלות הרטוריות שלי היא "כן") כן! יש דרך כזו! מנועי ביטוי רגולרי רבים מספקים רצף בריחה כגון "גבול מילים" \b. "גבול מילה" \bהוא רצף בריחה ברוחב אפס אשר, באופן מוזר, תואם גבול מילה. זכור שכאשר אנו אומרים "מילה", אנו מתכוונים לכל רצף של תווים בכיתה \wאו [A-Za-z0-9_]. התאמת גבול מילים פירושה שהתו מיד לפני או מיד אחרי הרצף \bחייב להיות неתו מילה. עם זאת, בעת התאמה, אנו לא כוללים את התו הזה במחרוזת המשנה שנתפסה. זה אפס רוחב. כדי לראות איך זה עובד, בואו נסתכל על דוגמה קטנה:

תבנית: \b[^ ]+\b 
מחרוזת:   Ve still vant ze money , Lebowski .
תואם: ^^ ^^^^^ ^^^^ ^^ ^^^^^ ^^^^^^^^  

( דוגמה ) הרצף [^ ]חייב להתאים לכל תו שאינו תו רווח מילולי. אז למה זה לא מתאים לפסיק ,אחרי כסף או לנקודה " .אחרי לבובסקי? הסיבה לכך היא שהפסיק ,והנקודה .אינן תווי מילים, ולכן נוצרים גבולות בין תווים של מילים לתווים שאינם מילים. הם מופיעים בין yסוף המילה. המילה כסף והפסיק ,שאחריה. ובין " iהמילה לבובסקי לנקודה .(נקודה/נקודה) שאחריה. הביטוי הרגולרי תואם בגבולות של מילים אלו (אך לא בתווים שאינם מילים שרק עוזרים להגדיר אותם). אבל מה קורה אם לא נכלול עקביות \bבתבנית שלנו?

דפוס: [^ ]+ 
מחרוזת:   Ve still vant ze money, Lebowski. 
תואם: ^^ ^^^^^ ^^^^ ^^ ^^^^^^ ^^^^^^^^^  

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

תבנית: \"\b[^"]{0.5}\b\"|\"\b[^"]+\s[^"]*\b\" 
string:   "12345" "הסיסמה שלי" " Xanadu. 2112" "su_do" "אנשי מכירות!"
תואם: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^  

( דוגמה ) על ידי הצבת גבולות מילים בתוך מרכאות ("\b ... \b"), אנו למעשה אומרים שהתו הראשון והאחרון של סיסמאות תואמות חייב להיות "תווי מילים". אז זה עובד מצוין כאן, אבל לא יעבוד טוב אם התו הראשון או האחרון בסיסמת המשתמש אינו תו מילה:

דפוס: \"\b[^"]{0.5}\b\"|\"\b[^"]+\s[^"]*\b\"
string: "thefollowingpasswordistoshort" "C++"
התאמות:   

( דוגמה ) ראה כיצד הסיסמה השנייה אינה מסומנת כ"לא חוקית" למרות שהיא קצרה מדי בבירור. אתה חייב להיותזָהִירעם רצפים \b, מכיוון שהם תואמים רק גבולות בין דמויות \wולא \w. בדוגמה שלמעלה, מכיוון שהרשינו תווים לא , בסיסמאות \w, הגבול בין \התו הראשון/אחרון של הסיסמה אינו מובטח להיות גבול מילים \b.

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

גבולות מילים שימושיים במנועי הדגשת תחביר כאשר אנו רוצים להתאים רצף ספציפי של תווים, אך רוצים לוודא שהם מתרחשים רק בתחילת או בסוף מילה (או בפני עצמם). נניח שאנחנו כותבים הדגשת תחביר ורוצים להדגיש את המילה var, אבל רק כשהיא מופיעה בפני עצמה (מבלי לגעת בתווים אחרים במילה). האם אתה יכול לכתוב ביטוי רגולרי עבור זה? כמובן שאתה יכול, זו משימה מאוד פשוטה ;)

תבנית:
מחרוזת:   var varx _var ( var j) barvarcar * var var -> { var }
תואם: ^^^ ^^^ ^^^ ^^^ ^^^  

( פתרון )

שלב 15: "קארט" ^כ"תחילת שורה" וסימן דולר $כ"סוף שורה"

רצף הגבול של המילה \b(מהשלב האחרון של החלק הקודם של המאמר) אינו הרצף המיוחד היחיד ברוחב אפס הזמין לשימוש בביטויים רגולריים. שני הפופולריים שבהם הם "קארט" ^- "תחילת שורה" וסימן דולר $- "סוף קו". הכללת אחד מאלה בביטויים הרגולריים שלך פירושה שההתאמה חייבת להופיע בתחילת או בסוף מחרוזת המקור:

תבנית: ^start|end$ 
מחרוזת:   התחלה סוף התחלה סוף התחלה סוף התחלה סוף 
התאמות: ^^^^^ ^^^  

( דוגמה ) אם המחרוזת שלך מכילה מעברי שורה, היא ^startתתאים לרצף "התחלה" בתחילת כל שורה, end$ותתאים לרצף "סוף" בסוף כל שורה (אם כי קשה להראות זאת כאן). סמלים אלה שימושיים במיוחד כאשר עובדים עם נתונים המכילים תוחמים. בוא נחזור לבעיית "גודל הקובץ" משלב 9 באמצעות ^"תחילת השורה". בדוגמה זו, גדלי הקבצים שלנו מופרדים על ידי רווחים " ". אז אנחנו רוצים שכל גודל קובץ יתחיל במספר, שלפניו תו רווח או תחילת שורה:

דפוס: (^| )(\d+|\d+\.\d+)[KMGT] 
מחרוזת B:   6.6KB 1..3KB 12KB 5G 3.3MB KB .6.2TB 9MB .
תואמים: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
קבוצה:    222 122 1222 12    

( דוגמה ) אנחנו כבר כל כך קרובים למטרה! אבל אולי תשים לב שעדיין יש לנו בעיה אחת קטנה: אנחנו מתאימים את תו הרווח לפני גודל הקובץ החוקי. כעת אנו יכולים פשוט להתעלם מקבוצת הלכידה הזו (1) כאשר מנוע הביטוי הרגולרי שלנו מוצא אותה, או שנוכל להשתמש בקבוצה שאינה לוכדת, אותה נראה בשלב הבא.

בינתיים, בואו נפתור 2 בעיות נוספות עבור הטון:

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

תבנית:
מחרוזת: myvec <- c(1, 2, 3, 4, 5)  
תואם:                          ^^^^^^^  

( פתרון ) מנתח פשוט עם ערכים מופרדים בפסיקים (CSV) יחפש "אסימונים" מופרדים בפסיקים. בדרך כלל, לרווח אין משמעות אלא אם כן הוא מוקף במרכאות "". כתוב ביטוי רגולרי לניתוח CSV פשוט המתאים אסימונים בין פסיקים, אך מתעלם (לא לוכד) מרווח לבן שאינו בין המרכאות.

תבנית:
מחרוזת:   a, "b", "c d",e,f, "g h", dfgi,, k, "", l 
תואמת: ^^ ^^^^ ^^^^^^^^^^ ^^^ ^^^ ^^^^^^ ^^ ^^^ ^ 
קבוצה:    21 2221 2222212121 222221 222211 21 221 2    

( פתרון ) RegEx: 20 צעדים קצרים לשליטה בביטויים רגולריים. חלק 4.