יש לי וידוי שיגרום לטהרני regex להתכווץ: במשך השנים הראשונות של הקריירה שלי, כתבתי ביטויים רגולריים על ידי העתקה מ-Stack Overflow, שינוי תו אחד, הפעלת הקוד, ראיתי אותו נכשל וחזרתי עד שזה קרה. work.I did't להבין את הדפוסים - הצקתי להם להיכנע. זה היה איטי, וגרוע מכך, הדפוסים ששלחתי היו שבירים בדרכים שיכולתי' לא לראות.
מה שתיקן את זה היה ' בקריאת התיאוריה (אם כי בסופו של דבר עשיתי זאת). זה היה בודק חזותי - קופסה שבה אני מקליד את התבנית, קופסה שבה אני מדביק מחרוזות בדיקה, והתאמות שמאירות ברגע שאני משנה משהו. פתאום יכולתי לראות למה \d+ תפס יותר ממה שרציתי, או למה דפוס הדואל שלי דחה כתובת חוקית לחלוטין Regex הפסיק להיות משחק ניחושים והפך לולאה משוב הדוק.
That's בדיוק מה ה בונה רגקס על Toolz.dev is.אתה כותב דפוס, ירידה בנתוני בדיקה, החלפת דגלים, ולצפות בהתאמות והקבוצות שנתפסו להדגיש בזמן אמת. it runs allow in your browser, so the log lines or user data you're testing against never get uploaded anywhere. this guide is the regex reference I wish I'd had between then - the patterns I actually reuse, a full cheat sheet, and the one mistake that can take down a production server.
TL;DR: הדבק את התבנית שלך ובדוק מחרוזות לתוך בונה רגקס ולהחליף את
g/i/mדגלים כדי לראות התאמות מדגישים בשידור חי. התחל פשוט, הוסף אילוצים כדי להרוג תוצאות חיוביות שגויות, ובדוק תשומות יריבות כדי למנוע חזרה קטסטרופלית. לנתונים שחולצו, חבר אותו עם פורמט JSON ו ממיר Base64. הכל בצד הלקוח, הכל בחינם.
מהו בדיוק ביטוי רגולרי?
ביטוי רגולרי - regex או regexp - הוא מחרוזת קומפקטית המתארת תבנית חיפוש במקום " find the word cat," you can say "find any five-digit number," "find anything that looks like an email," or "find every line that starts with ERROR." Nearly every language and editor supports them, that is what makes the skill so portable: learn it once and you use it in JavaScript, Python, your grep, וה-IDE's שלך מצא והחלף.
המושג יוצא מתורת השפה הפורמלית משנות ה-1950, וקן תומפסון חיבר אותו למחשוב בשנות ה-1960 לעריכת טקסט. That history matters for one practical reason I'll come back to: "regular" languages have limits, that is why regex really cannot parse nested structures like HTML never matter how clearn you get.
איפה אני מגיע ל-regex בשבוע רגיל: אימות קלט משתמש לפני שהוא מגיע למסד הנתונים, שליפת שדות מקווי יומן לא מובנים, ביצוע חיפוש והחלפה על פני בסיס קוד שלם שחיפוש רגיל יכול ' לבטא, וסינון נתונים במהלך הגירה. ה בונה רגקס זה המקום שבו אני אב טיפוס של כל אחד מאלה לפני שהוא מתקרב לקוד אמיתי.
הנה אבני הבניין הבסיסיות - האלפבית שממנו אתה מרכיב דפוסים:
| תחביר | משמעות | דוגמה | התאמות |
|---|---|---|---|
. |
כל דמות מלבד שורה חדשה | h.t |
כובע, לוהט, מכה |
\d |
כל ספרה (0-9) | \d{3} |
123, 456 |
\w |
תווים של מילים (az, AZ, 0-9, _) | \w+ |
שלום, מבחן_123 |
\s |
כל רווח לבן | hello\sworld |
שלום עולם |
^ |
תחילת מחרוזת | ^Hello |
שלום בהתחלה |
$ |
סוף המחרוזת | end$ |
סוף בסוף |
* |
אפס או יותר | ab*c |
ac, abc, abbc |
+ |
אחד או יותר | ab+c |
abc, abbc |
? |
אפס או אחד | colou?r |
צבע, צבע |
{n} |
בדיוק n פעמים | \d{4} |
2026 |
{n,m} |
בין n ל-m | \d{2,4} |
12, 123, 1234 |
[abc] |
כיתת אופי | [aeiou] |
כל תנועה |
[^abc] |
כיתה מבוטלת | [^0-9] |
כל אי-ספרה |
(...) |
קבוצת לכידה | (hello) |
לוכד "hello" |
a|b |
החלפה (או) | cat|dog |
חתול או כלב |
אילו דפוסי Regex כל מפתח צריך לשמור בהישג יד?
אלה הם אלה I' בדקת, שבורה, תוקנה, ועכשיו לשמור בקובץ קטע אישי. העתק אותם ישר לתוך בונה רגקס ולזרוק עליהם תיקי קצה משלך.
אימייל (הסוג המעשי)
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
זה תואם [email protected] ו [email protected], ודוחה @example.com או user@com. Here' עם זאת, הכנות החשובה: דקדוק הדואל המלא ב RFC 5322 הוא מורכב בצורה מפלצתית - הוא מאפשר מבחינה טכנית מחרוזות מצוטטות והערות שכמעט אף אחד לא משתמש בהן. Don't chase 100% RFC compliance with a regex.Match the practical 99% with the pattern above, then confirm the address is real by sending a verification email. That's the mistake I see most: teams burning days on an "airtight" email regex that still can't tell a real inbox from a typo.
כתובת אתר
^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/=]*)$
התאמות https://toolz.dev ו http://www.example.com/path?query=value; דוחה ftp://... וטקסט רגיל.
מספר טלפון בארהב
^(\+1)?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$
גמיש מספיק עבור 555-123-4567, (555) 123-4567, +1 555.123.4567, ו 5551234567.
כתובת IPv4
^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
החלופה המקוננת היא זו שאוכפת שכל אוקטט נשאר ב-0–255, ולכן היא דוחה נכון 999.999.999.999.
בדיקת סיסמא חזקה
^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$
דורש לפחות 8 תווים עם אותיות קטנות, אותיות גדולות, ספרה וסמל. ה (?=...) כל אחד מהם טוען תנאי אחד מבלי לצרוך דמויות - טריק מסודר שכדאי להבין.
תאריך ISO (YYYY-MM-DD)
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$
התאמות 2026-07-11, דוחה 2026-13-01 ו 2026-02-32.
צבע HEX
^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$
התאמות #4466EE, #abc, #000000.
גיליון הרמאות של Regex
שמור את זה מוצמד. It's ההתייחסות שאני בודק הכי הרבה.
עוגנים
| דפוס | תיאור |
|---|---|
^ |
תחילת מחרוזת (או שורה במצב רב שורות) |
$ |
סוף המחרוזת (או שורה במצב רב שורות) |
\b |
גבול מילים |
\B |
גבול שאינו מילה |
מכמתים
| דפוס | תיאור |
|---|---|
* |
0 או יותר (חמדן) |
+ |
1 או יותר (חמדן) |
? |
0 או 1 (חמדן) |
*? +? ?? |
גרסאות עצלות - תואמות כמה שפחות |
{n} {n,} {n,m} |
בדיוק n / n או יותר / בין n ל-m |
שיעורי אופי
| דפוס | תיאור |
|---|---|
[abc] |
a, b, או c |
[^abc] |
לא a, b, או c |
[a-z] [A-Z] [0-9] |
טווחים |
\d \D |
ספרה / לא ספרתית |
\w \W |
תו מילה / תו לא מילה |
\s \S |
Whitespace / non-whitespace |
קבוצות ומבט מסביב
| דפוס | תיאור |
|---|---|
(abc) |
קבוצת לכידה |
(?:abc) |
קבוצה לא לוכדת |
(?<name>abc) |
קבוצת לכידה בשם |
(?=abc) / (?!abc) |
מבט חיובי / שלילי קדימה |
(?<=abc) / (?<!abc) |
מבט חיובי / שלילי מאחור |
דגלים
| דגל | תיאור |
|---|---|
g |
גלובלי - מצא את כל ההתאמות |
i |
לא רגיש למקרה |
m |
רב קו - ^ ו $ התאם גבולות קו |
s |
דוטאל - . תואם קווים חדשים |
u |
תמיכה ביוניקוד |
איך בונים ומנקים באגים בדפוס מבלי להפסיד שעה?
התהליך שלי משעמם בכוונה, כי משעמם ניתן לחזור:
- התחילו בדבר הפשוט ביותר שתואם דוגמה אמיתית אחת. Don't נסה לטפל בכל מקרה בבת אחת.
- הדבק מחרוזות בדיקה חיוביות ושליליות כאחד לתוך ה בונה רגקס- דברים שצריכים להתאים ודברים שאסור.
- להדק להרוג חיובי שווא. הוסף עוגנים (
^,$) אז התבנית תואמת את כל המחרוזת, והחלפה.לשיעורים ספציפיים כמו[a-z]או[^,]. - לזרוק עליו מידע יריב- מחרוזות ריקות, כניסות ענק, Unicode ותווי regex מילוליים כנתונים.
- רק אז לייעל.
כשמשהו מתנהג לא נכון, זה ' הוא כמעט תמיד אחד משלושה דברים. אם זה גפרורים יותר מדי, המכמתים שלך חמדנים - הפוך אותם לעצלנים (*?) או השיעורים שלך ספציפיים יותר. אם זה תואם מעט מדי, אתה כנראה צריך את i דגל או שכח לברוח דמות מיוחדת. If it לא תואם כלום, בדוק אם יש מטא-תווים שלא נמלטו (., *, +, (, [, {' וכו') נועד להיות מילולי, או תווים בלתי נראים כמו כרטיסיות מסתתרות במחרוזת הבדיקה שלך.
מהי חזרה קטסטרופלית, ולמה כדאי לפחד ממנה?
זה הסעיף I' d קעקוע על מפתחים חדשים אם יכולתי. בשלב מוקדם שלחתי regex אימות קלט שנראה תמים לחלוטין, ואחר צהריים אחד בקשה בודדת הצמידה ליבת CPU ל-100% ונשארה שם. הדפוס היה הבעיה.
כאשר מנוע regex יכול ' לא למצוא התאמה, זה מסלולים אחוריים- הוא נסוג ומנסה דרכים אחרות לספק את התבנית צורות מסוימות גורמות למספר הנתיבים להתפוצץ באופן אקספוננציאלי. הדוגמה של ספר הלימוד:
^(a+)+$
להאכיל שקלט כמו aaaaaaaaaaaaaaaaaaaab (ריצה של a מסתיים ב-a b), והמכמתים המקוננים נותנים למנוע מספר אסטרונומי של דרכים לחלק את as, את כל מה שהיא מנסה לפני סיום "no match." האפליקציה שלך קופאת. זהו שיעור מניעת שירות אמיתי שנקרא ReDoS (מניעת שירות של ביטוי רגיל), והתוקפים אכן מנצלים אותו.
איך להישאר בטוחים:
- לעולם אל תכמת מכמים.
(a+)+,(a*)*, ו(a+)*הם דגלים אדומים. - השתמש בקבוצות אטומיות או במכמים רכושניים היכן המנוע תומך בהם:
(?>a+)אוa++. - תהיה ספציפי.
[a-z]+מסלולים אחוריים פחות מ.+כי יש לו פחות נתיבים לחקור. - עגן את הדפוסים שלך אז המנוע נכשל מהר בקלט שאינו תואם.
- בדוק עם מחרוזות שכמעט תואמות אך נכשלות ממש בסוף- that' הוא המקרה הגרוע ביותר עבור חזרה לאחור.
אם אתה're on Go, הבעיה הזו פשוט קיימת 't, מה שמביא אותי לסעיף הבא.
איך Regex שונה בין שפות?
תחביר הליבה נוסע היטב, אבל הפרטים נושכים. אלו ההבדלים I' למעשה מעדו.
JavaScript:
const regex = /\d{3}-\d{4}/g;
const pattern = new RegExp('\\d{3}-\\d{4}', 'g'); // note the doubled backslashes
'555-1234'.match(regex); // ["555-1234"]
const m = '2026-07-11'.match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/);
m.groups.year; // "2026"
היזהרו: lookbehind הגיע רק ב-ES2018, \d מתאים לספרות ASCII בלבד, וה g דגל עושה .test() stateful ויה lastIndex- מקור באג עדין בלולאות.
פייתון:
import re
pattern = re.compile(r'\d{3}-\d{4}') # raw strings avoid double-escaping
pattern.findall('Call 555-1234 or 555-5678') # ['555-1234', '555-5678']
השתמש תמיד במחרוזות גולמיות (r'...'). זכור re.match רק עוגנים בהתחלה - השתמש re.search למצוא בכל מקום. ו re.VERBOSE מאפשר לך לכתוב דפוסי הערות מרובי שורות, המהווה מציל חיים עבור מורכבים.
PHP: דפוסים צריכים תוחמים ('/\d{3}-\d{4}/'), הוא משתמש במנוע PCRE החזק, ו preg_match החזרות 1, 0, או false על שגיאה - אז בדוק עם ===.
ללכת: משתמש במנוע RE2, אשר בכוונה טיפות מבט, מבט מאחור והפניות לאחור בתמורה להבטחה של התאמת זמן ליניארית. זה אומר שאפילו לא ניתן לחזור אחורה קטסטרופלי - פשרה שונה באמת שכדאי לדעת כשאתה בוחר שפה להתאמת קלט לא מהימנה.
דוגמה אמיתית: ניתוח קו יומן אפאצ'י
Here's סוג הדברים ש-regex באמת נהדר בהם. שורת יומן גישה סטנדרטית לאפאצ'י נראית כך:
192.168.1.1 - frank [11/Jul/2026:10:27:10 -0500] "GET /api/users HTTP/1.1" 200 1234
דפוס זה מפרק אותו:
^(\S+) \S+ (\S+) \[([^\]]+)\] "(\S+) (\S+) (\S+)" (\d{3}) (\d+)$
הדבק את שניהם לתוך בונה רגקס וכל קבוצה שנלכדה נדלקת בנפרד:
| קבוצה | תוכן | דוגמה |
|---|---|---|
| 1 | כתובת IP | 192.168.1.1 |
| 2 | שם משתמש | פרנק |
| 3 | חותמת זמן | 11/יולי/2026:10:27:10 -0500 |
| 4 | שיטת HTTP | לקבל |
| 5 | נתיב בקשה | /api/משתמשים |
| 6 | גרסת HTTP | HTTP/1.1 |
| 7 | קוד סטטוס | 200 |
| 8 | גודל תגובה | 1234 |
ברגע שהקבוצות מסתדרות בבוחן, מתרגמים את זה ל-a re.findall בפייתון או א match() ב-javascript זה טריוויאלי - ואתם כבר יודעים שזה עובד.
שאלות נפוצות
מהו בונה regex?
בונה regex הוא כלי אינטראקטיבי שבו אתה מקליד ביטוי רגולרי ומיד רואה אותו מותאם למחרוזות בדיקה, עם התאמות וקבוצות שנתפסו מודגשות. זה מחליף את לולאת הכתיבה האיטית-הפעלה-כשל-שכתוב בקוד שלך בלולאה חיה. ה בונה רגקס ב-Toolz.dev עושה זאת לחלוטין בדפדפן שלך, כך שנתוני הבדיקה נשארים במחשב שלך.
האם דפוסי regex זהים בכל שפת תכנות?
תחביר הליבה כמעט זהה, אבל הפרטים שונים מספיק כדי לגרום לבאגים. JavaScript ישן יותר חסר lookbehind, Go' למנוע RE2 אין מבט או הפניות לאחור כלל, ו-Python שם קבוצות עם (?P<name>...) בהקשרים מסוימים. תמיד אשר דפוס בשפה שבה אתה & #39; הם למעשה מכוונים במקום להניח ניידות.
כיצד אוכל לאמת כתובת דואר אלקטרוני עם regex?
השתמש בתבנית מעשית כמו ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$, המטפל ברוב המכריע של הכתובות האמיתיות. אל תנסה תאימות מלאה ל-RFC 5322 ב-regex - הדקדוק מורכב מדי ואתה ' עדיין תדחה כתובות חוקיות או תקבל שגיאות הקלדה. חבר את ה-regex עם דואל אימות כדי לאשר שתיבת הדואר הנכנס אכן קיימת.
מדוע regex שלי להקפיא את היישום?
כמעט תמיד חזרה קטסטרופלית. דפוסים עם מכמים מקוננים כמו (a+)+ צור מספר אקספוננציאלי של נתיבים תואמים כאשר הם פוגשים קלט שכמעט תואם אך בסופו של דבר נכשל, והמנוע מנסה את כולם. הסר מכמים מקוננים, העדיף מחלקות תווים ספציפיות על פני .+, והוסף עוגנים כדי שהמנוע יוכל להיכשל במהירות.
האם אני יכול להשתמש ב-regex כדי לנתח HTML או JSON?
לא, לא לשום דבר מעבר לחילוץ טריוויאלי HTML ו-JSON אינן שפות רגילות - הן מאפשרות קינון שרירותי ש-regex ביסודו לא יכול לעקוב אחריו השתמש במנתח אמיתי: DOMParser או Cheerio עבור HTML, ו JSON.parse או כלי JSON עבור JSON. Regex הוא הכלי הלא נכון ברגע שמבנה מקנן.
What's ההבדל בין התאמה חמדנית לעצלנית?
מכמים חמדנים (*, +, ?) לתפוס כמה שיותר ולחזור במידת הצורך; עצלנים (*?, +?, ??) לתפוס כמה שפחות ולהרחיב רק אם נאלץ. Against <b>bold</b>, חמדן <.*> בולע את כל החוט בעצלתיים <.*?> עוצר בראשון <b>. הבחירה הנכונה היא לעתים קרובות התיקון כאשר דפוס תואם יותר מדי.
איך אני בורח מדמויות מיוחדות ב-regex?
שים קו נטוי אחורי מול כל מטא-דמות שאתה מתכוון מילולית: \., \*, \+, \?, \(, \), \[, \], \{, \}, \^, \$, \|, ו \\. רוב השפות מציעות גם עוזר לברוח מחרוזת שלמה עבורך - re.escape() ב-python, למשל - שהוא בטוח יותר מאשר בריחה ביד כאשר המחרוזת מגיעה מקלט משתמש.
מה המשמעות של דגלי regex g, i, ו-m?
g (גלובלי) מוצא כל התאמה במקום לעצור בהתחלה, i (התעלם ממקרה) הופך את הדפוס לבלתי רגיש למקרה, ו m (מולטיליין) עושה ^ ו $ התאמה בכל הפסקת שורה ולא רק את המחרוזת's להתחיל ולסיים. הם משתלבים בחופשיות, אז gim עושה את שלושתם. gotcha תכוף ב-JavaScript: שימוש חוזר ב-a g regex על פני שיחות נושאת lastIndex ביניהם, מה שהופך test() החלף אמת ושקר - צור מחדש את התבנית או אפס lastIndex.
מה זה מבט קדימה ב-regex?
מבט קדימה טוען שמשהו עושה או עושה 't לעקוב, מבלי לצרוך אותו. foo(?=bar) גפרורים foo רק כאשר bar מגיע הבא; foo(?!bar) תואם רק כאשר זה עושה 't. תסתכל מאחור ((?<=...), (?<!...)) עושה את אותו הדבר לאחור, ונחת ב-JavaScript, Python ו-PCRE המודרניים - אבל לא ב-Go's RE2, שדוחה את שניהם על הסף. כללי סיסמה הם השימוש הקלאסי: ^(?=.*\d)(?=.*[a-z]).{8,}$ מערם הצהרות כך שכל דרישה נבדקת באופן עצמאי באותו מיקום.
כיצד אוכל להתאים מספר טלפון עם regex?
עבור פורמט ספציפי, היה מפורש ולא חכם: ^\(\d{3}\) \d{3}-\d{4}$ גפרורים (555) 123-4567. כדי לסבול מפרידים מגוונים, אפשר מפרידים אופציונליים כמו ^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$. מספור הטלפון מבולגן בין מדינות, אז אמת רק את הפורמט שאתה מקבל בפועל ונרמל לספרות לפני האחסון - בנה ובדוק את הדפוס בשידור חי לפני שאתה סומך עליו.
עוטף
Regex עבר מהמיומנות הכי מפחידה שלי לאחד מהשימושים ביותר שלי ברגע שהתחלתי לבנות דפוסים בבוחן חי במקום לנחש בעורך שלי. התחל פשוט, בדוק מול קלט אמיתי ויריבי, כבד חזרה קטסטרופלית ושמור ספרייה אישית של דפוסים שאתה סומך עליהם.
ה בונה רגקס ב-Toolz.dev הופך את הלולאה הזו למהירה, עם התאמה בזמן אמת, הדגשת קבוצות והחלפת דגלים - כולם פועלים בדפדפן שלך כך שנתוני הבדיקה שלך יישארו פרטיים. כאשר הדפוס שלך מחלץ את JSON, מסור אותו ל- פורמט JSON; כאשר הוא לוכד כתם Base64, פענח אותו עם ממיר Base64. או עיין בכל 600+ הכלים החינמיים בכתובת Toolz.dev.
