ה-regex שעלה לי הכי הרבה זמן היה אחד שלא כתבתי. זה היה בן ארבע, ישב בשכבת אימות, ונראה כאילו חתול עבר על המקלדת: קבוצות מקוננות, מבט קדימה, שתי כיתות דמויות וא {2,} מסתתר בסוף כרטיס תמיכה אמר שהוא דוחה קלט תקף, ולפני שהספקתי לתקן אותו הייתי צריך להבין את זה, מה שאומר להפעיל את המנוע נפשית על התבנית אסימון אחד בכל פעם זה המס שכל מפתח משלם על regex לא מוכר, וזה בדיוק המס את מסביר regex על Toolz.dev בנוי להסיר מדריך זה הוא על קריאת ביטויים רגולריים במקום לפענח אותם, וכיצד פירוט אסימון אחר אסימון הופך קיר של סמלים למשהו שאתה יכול לסקור כמו קוד רגיל.
TL;DR: מסביר regex מנתח ביטוי רגולרי ומתאר כל חלק באנגלית פשוטה, לפי סדר קריאתו של המנוע: עוגנים, מחלקות תווים, מכמים, קבוצות, תצפיות ובריחות, כל המבנה המסומן והמחורץ כל כך מקונן נראה לעין מסביר regex מאמת את הדפוס עם מנוע ה-JavaScript האמיתי ועושה את כל התקלה בדפדפן שלך, בלי שום דבר שהועלה.
מהו regex explainer?
מסביר regex לוקח ביטוי רגולרי ומתרגם אותו, מבנה אחד בכל פעם, לתיאור שאתה יכול לקרוא במקום לבהות בו ^(?<user>[a-z0-9._%+-]+)@ ושחזור המשמעות שלו בראש שלך, אתה מקבל רשימה מסודרת: זהו עוגן התחלה של מחרוזת, זוהי קבוצת לכידה בשם הנקראת משתמש, זוהי מחלקת תווים התואמת לאות קטנה, ספרה, נקודה, סימן אחוז, פלוס או מקף, ומכמת זה אומר פעם אחת או יותר הדפוס לא השתנה, אבל המאמץ להבין אותו עבר מהראש שלך לכלי.
הערך נובע מהעובדה שביטויים רגולריים הם קומפקטיים בכוונה כל סמל נושא משמעות, ואת אותה כוונה ניתן לכתוב בדרכים רבות ושונות, כך שאין דרך אמינה לרפרף על תבנית כמו שאתה מרפרף על פונקציה. קו נטוי תועה בודד משנה נקודה מילולית לתוך "כל תו," ומכמת חמדן שבו רצית עצלן משנה איזה טקסט קבוצה לוכדת. קריאה נכונה של regex פירושה הדמיית המנוע, והדמיית המנוע ביד איטית ונוטה לשגיאות. המסביר עושה את הסימולציה הזו ומראה לך את התוצאה.
על Toolz.dev הזרימה קצרה אתה מדביק את התבנית ללא הסלאשים הסובבים אותה, מחליף את הדגלים שבהם הוא משתמש, והפירוט מופיע מיד קבוצות מקוננות מחורצות כך שצורת התבנית נראית במבט חטוף, וכל דגל מתואר בהקשר כך שאתה מבין כיצד הוא משנה את כל ההתאמה ולא רק את התחביר.
במה שונה מסביר מבוחן רגקס?
שני הכלים האלה עונים על שאלות שונות, ולדעת מה אתה צריך חוסך זמן בודק regex מריץ תבנית מול טקסט לדוגמה ומראה מה הוא מתאים: ההתאמות המודגשות, קבוצות הלכידה וכל שגיאה. It answers "does this pattern do what I want on this input." An explainer describes what the pattern means without any test input at all.It answers "what is this pattern actally saying."
אתה מושיט יד למסביר כאשר ה-regex הוא הלא ידוע, לא הנתונים. סקירת בקשת משיכה שמוסיפה דפוס אימות, ירושה של בסיס קוד מלא בביטויים לא מתועדים, או ניסיון להבין תשובה שהעתקת מפורום הם כולם מקרים שבהם יש לך את הדפוס ואתה צריך לדעת מה הוא עושה לפני שאתה סומך עליו. אתה מושיט יד אל בודק רגקס כאשר אתה כבר מבין את הדפוס ורוצה לאשר את התנהגותו מול דוגמאות אמיתיות בפועל השניים עובדים כזוג: להסביר דפוס כדי להבין אותו, ואז לבדוק אותו כדי להוכיח אותו הבוחן והמסביר יושבים אחד ליד השני על Toolz.dev בדיוק מהסיבה הזאת.
יש כלי שלישי במשפחה ששווה לתת לו שם. ה בונה רגקס מרכיב תבנית מרכיבים ותבניות כאשר אתה מתחיל מאפס בנה, הסבר, בדוק: שלושת אלה מכסים את מחזור החיים המלא של עבודה עם ביטוי רגולרי, מכתיבת אחד אתה עדיין לא צריך להבין אחד שלא כתבת.
מה בעצם מראה הפירוט?
המסביר הולך על התבנית משמאל לימין ופולט שורה אחת מסומנת לכל מבנה, לפי סדר שבו המנוע נתקל בהם. הסדר הזה חשוב, כי ביטוי רגולרי נקרא ברצף, ולראות את האסימונים ברצף משקף את אופן ההתאמה בפועל.
עוגנים באים ראשונים ברוב הדפוסים. ה ^ ו $ סמלים אינם תואמים תווים; הם טוענים מיקום, ההתחלה והסוף של המחרוזת, או ההתחלה והסוף של כל שורה כאשר הדגל הרב-קו מוגדר. המסביר מציין את ההתנהגות הכפולה הזו, כך שלעולם אינך מופתע מעוגן שמתנהג אחרת מתחת ל- m דגל.
מחלקות תווים, הכתובות בסוגריים מרובעים, מתארות תו בודד שנלקח מקבוצה. המסביר מרחיב את הסט למילים: טווחים כמו a-z הפוך ל-"הטווח a עד z," קיצור בורח כמו \d הפוך ל-" ספרה," וקארט מוביל הופך ל-"כל דמות שאינה" הסט הרשום. מחלקה צפופה כמו [a-zA-Z0-9._%+-] קורא כרשימה פשוטה במקום פאזל.
מכמתים הם המקום שבו חיים באגים עדינים, כך שהם מקבלים קווים משלהם. א * הוא אפס או יותר, + הוא אחד או יותר, ? הוא אפס או אחד, ו {n,m} הוא טווח מפורש באופן מכריע, המסביר מסמן מכמים עצלנים, אלה שנכתבו עם נגרר ? כגון +? או *?, כי ההבדל בין חמדן לעצלן משנה איזה טקסט לוכד דפוס מבלי לשנות דמות אחת גלויה במקום אחר.
קבוצות ומבטים מחורצים כדי להראות קינון. קבוצות לוכדות, קבוצות שאינן לוכדות, קבוצות עם שם וכל ארבעת סוגי המבט מסביב מקבלים כל אחד תיאור של מה שהם עושים, ותבנית הילד בתוכם מחורצת ברמה אחת כך שהמבנה נקרא כמו קו מתאר מקונן ולא רצף שטוח של סמלים.
הנה איך המבנים הנפוצים ממפים למה שהמסביר אומר לך:
| לבנות | דוגמה | מה המסביר אומר |
|---|---|---|
| עוגן | ^ |
Start-of-string (או התחלה של קו עם דגל m) |
| כיתת אופי | [a-z] |
תו בודד מהטווח a עד z |
| קיצור | \d |
ספרה, 0 עד 9 |
| מְכַמת | {2,} |
חוזר על עצמו 2 פעמים או יותר |
| מכמת עצלן | +? |
חזר על עצמו פעם אחת או יותר, כמה שפחות |
| קבוצת לכידה | (...) |
התחלה של קבוצה לוכדת, נשמרת לשימוש חוזר |
| קבוצה בשם | (?<id>...) |
התחלה של קבוצת לכידה בשם "id" |
| תסתכל קדימה | (?=...) |
התבנית המצורפת חייבת לעקוב, אך אינה נצרכת |
| הפניה לאחור | \1 |
תואם לאותה קבוצת טקסט 1 שנלכדה |
התיאורים עוקבים אחר הטרמינולוגיה המשמשת ב- התייחסות לביטויים רגולריים של MDN, אז אם אתה רוצה לקרוא עוד על כל מבנה בודד, המילים בפירוט הן המילים שיש לחפש.
למה הטעם משנה?
ביטויים רגולריים אינם שפה אחת; הם משפחה של אלה הקשורים זה לזה. JavaScript, PCRE (בשימוש על ידי PHP וכלים רבים), Python's re מודול, Java ו.NET חולקים כולם את תחביר הליבה, אבל הם מתפצלים בקצוות, והקצוות האלה הם המקום שבו מתרבה בלבול. ה-Regex Explainer מתאר ביטויים רגולריים של JavaScript, הטעם המשמש את הדפדפנים ואת Node.js, כי זה מה שהכלי מאמת מולו ומה שרוב מפתחי האינטרנט באמת מריצים.
הליבה המשותפת גדולה ואמינה מחלקות תווים, המכמים הנפוצים, חילופין עם |, קיבוץ, עוגנים, והקיצורים הסטנדרטיים כמו \d ו \w מתכוון לאותו דבר בכל מקום אם הדפוס שלך משתמש רק באלה, ההסבר מדויק ללא קשר לשפה שבה בסופו של דבר תריץ אותו. ההבדלים הם בתכונות המתקדמות: מבט מאחורי התמיכה הגיעה מאוחר ב-JavaScript ושונה מ-PCRE, תחביר קבוצתי בשם משתנה בין טעמים, ומנועים מסוימים תומכים ברקורסיה או מכמתים רכושניים שאין ל-JavaScript כלל.
הכלל המעשי פשוט. התייחסו להסבר של המבנים המשותפים כסמכותיים, ובדקו שוב כל הרחבה ספציפית לטעם מול התיעוד של שפת היעד שלכם. מכיוון שהמסביר מאמת את התבנית עם מנוע ה-JavaScript האמיתי תחילה, מבנה ש-JavaScript אינו תומך בו יופיע כשגיאה ולא כהסבר שגוי, וזה הכישלון הבטוח יותר. אם אתה עובד על פני המחסנית כמוני, נע בין קצה אחורי של PHP לחזית JavaScript, מפורש לגבי הטעם מציל את מחלקת הבאג שבה דפוס שעבד במקום אחד מתנהג בצורה לא נכונה במקום אחר.
איך אני קורא איתו דפוס אמיתי?
קח את המדגם שהכלי טוען כברירת מחדל, דפוס בצורת דואר אלקטרוני: ^(?<user>[a-z0-9._%+-]+)@(?<domain>[a-z0-9.-]+\.[a-z]{2,})$ עם הדגל חסר הרגישות לאותיות רישיות בפני עצמו הוא פתית הפעל אותו דרך המסביר והוא מתפרק לקו מתאר קצר וקריא.
ה ^ טוען את תחילת המחרוזת הקבוצה הראשונה בשם, משתמש, לוכדת תו אחד או יותר ממחלקה של אותיות קטנות, ספרות, ואת סימני הפיסוק המותרים בדרך כלל בחלק המקומי של כתובת. ואז מילולי @. הקבוצה, התחום השני, לוכדת אות אחת או יותר, ספרות, נקודות או מקפים, ואחריה נקודה מילולית ורצף של שתי אותיות או יותר, שהיא התחום ברמה העליונה. לבסוף $ טוען את סוף המחרוזת. ה i דגל פירושו שכל העניין תואם ללא קשר לאותיות גדולות, כך שהמחלקות באותיות קטנות בלבד עדיין מקבלים קלט באותיות גדולות.
תקראו ככה קופצים החוצה שני דברים שהם בלתי נראים בתבנית הגולמית ראשית, ה {2,} בדומיין ברמה העליונה פירושו שהתבנית מקבלת כל TLD של שתי אותיות או יותר, מה שנכון לדומיינים מודרניים אך ידחה TLD בינלאומי שנכתב בתווים שאינם לטיניים. שנית, העוגנים פירושם שהתבנית חייבת להתאים לכל המחרוזת, כך שהיא מאמתת כתובת שלמה במקום למצוא אחת בתוך טקסט גדול יותר. אלו בדיוק סוגי הפרטים שקובעים אם regex אימות קפדני מדי או רופף מדי, והם ברורים בפירוק תוך שקל לפספס אותם במקור.
ברגע שאתה מבין דפוס, אתה רוצה לעתים קרובות לעשות איתו משהו. אם זה דפוס למצוא ולהחליף, ה החלפת Regex הכלי מריץ את ההחלפה עם תמיכה בהפניה לאחור. אם זה דפוס חילוץ, ה חולץ דואל מחיל גרסה אוצרת של סוג זה בדיוק של התאמת דואל לטקסט בכמות גדולה. המסביר הוא שלב הקריאה; אלו הם שלבי הפעולה.
מתי באמת אשתמש בזה?
סקירת קוד היא המקרה שפגעתי בו יותר מכל חבר לצוות מוסיף ביטוי רגולרי לשכבת אימות או מנתח יומן, וההבדל מראה שורה של סמלים ללא הערה הדבקתו במסביר הופכת מבט של חמש דקות לקריאה של עשר שניות, והיא תופסת את הפספוסים של הביקורת הקלאסית: נקודה לא נמלטת התואמת לכל דמות, מכמת חמדן שלוכד יותר מדי, עוגן שנוכח או נעדר כאשר זה אמור להיות בכיוון השני התחלתי להדביק את הפירוט לבקשת המשיכה כהערה, שמתעדת את הדפוס עבור האדם הבא בחינם.
למידה היא הבאהביטויים רגולריים הם אחת מאותן מיומנויות שלעולם לא נדבקות באופן מלא אלא אם כן אתה משתמש בהן מדי יום, וחזרה אליהן לאחר מספר חודשים פירושה תמיד ללמוד מחדש את התחביר קריאת תבניות אמיתיות עם המסביר היא דרך מהירה יותר חזרה מאשר קריאה חוזרת של מדריך, מכיוון שאתה רואה את המבנים בהקשר, עושה עבודה אמיתית, ולא כדוגמאות מבודדות עם הזמן התיאורים הופכים למיותרים כי הפנמת אותם, וזה העניין.
איתור באגים סוגר את הלולאה כאשר תבנית תואמת לדבר הלא נכון, ההסבר מגלה לעיתים קרובות מדוע לפני שאתה בכלל מושיט יד לקלט בדיקה מכמת שהוא חמדן כאשר הוא צריך להיות עצלן, מחלקת תווים הכוללת תו ששכחת ממנו, עוגן חסר המאפשר לתבנית להתאים למחרוזת משנה: כל אלה גלויים בפירוק אני שומר את המסביר ליד ה בודק רגקס אז אני יכול להסביר ולבדוק באותה ישיבה, ושניהם חיים בערכה הרחבה יותר שתיארתי ב- מדריך ערכת כלים למפתחי אינטרנט.
האם זה פרטי, והאם זה עובד במצב לא מקוון?
כן לשניהם, ומאותה סיבה כל הפירוט מחושב ב-JavaScript בתוך הדפדפן שלך הדפוס לעולם לא נשלח לשרת, שום דבר לא נרשם, וברגע שהדף נטען הכלי ממשיך לעבוד כשהחיבור שלך מושבת אתה יכול לאשר זאת על ידי פתיחת לשונית הרשת או על ידי מעבר למצב לא מקוון וצפייה בה ממשיכה לתפקד.
זה משנה יותר ממה שזה עשוי להיראות עבור ביטויים רגולריים באופן ספציפי דפוסים נכתבים לעתים קרובות כדי להתאים פורמטים רגישים: מזהים פנימיים, צורות מפתח API, פריסות מספר חשבון, או המבנה של נתונים פרטיים הדבקת אחד מאלה לתוך כלי בצד השרת פירושו מסירת תיאור של פורמט הנתונים שלך לצד שלישי שמירה על הניתוח בצד הלקוח פירושה שהתבנית נשארת במחשב שלך, וזה אותו עיקרון פרטיות ראשון מאחורי כל כלי ב-Toolz.dev, ואחד שכתבתי עליו באופן מלא יותר ב מדריך פרטיות נתונים.
שָׁוא
איך אני מבין ביטוי רגולרי מורכב?
הדבק את התבנית במסביר וקרא את פירוט האסימון אחר אסימון, המתאר כל מבנה באנגלית פשוטה לפי סדר החלת המנוע. קבוצות מקוננות מחורצות כך שתוכל לראות את המבנה. זה הופך את הדמיית המנוע נפשית לקריאת רשימה מסומנת, שהיא מהירה יותר ונוטה הרבה פחות לשגיאות.
מה ההבדל בין regex explainer לבין regex tester?
מסביר regex מתאר מה המשמעות של דפוס ללא כל קלט בדיקה, בעוד שבוחן regex מריץ את התבנית מול טקסט לדוגמה ומראה מה הוא תואם השתמש במסביר כדי להבין או לתעד דפוס לא מוכר, ולאחר מכן השתמש בבוחן כדי לאשר שהוא מתנהג כצפוי מול נתונים אמיתיים הם עונים על שאלות שונות ועובדים היטב כזוג.
איזה טעם regex מתאר המסביר?
הוא מתאר ביטויים רגולריים של JavaScript (ECMAScript), הטעם המשמש את הדפדפנים ו-Node.js. רוב התחביר, כולל מחלקות תווים, מכמתים, קבוצות ועוגנים, משותף עם PCRE, Python ו-Java, כך שהסבר הליבה מדויק בין שפות. תכונות ספציפיות לטעם כמו lookbehind ותחביר של קבוצה בשם יכולות להיות שונות, אז ודא אותן מול שפת היעד שלך.
מה ההבדל בין מכמת חמדן למכומת עצלן?
מכמת חמדן כגון + או * מתאים לכמה שיותר טקסט לפני החזרה לאחור, בעוד מכמת עצלן, אותו סמל ואחריו ? כגון +? או *?, תואם כמה שפחות. המסביר מתייג מכמתים עצלנים במפורש, מכיוון שההבדל משנה איזה טקסט תבנית לוכדת מבלי לשנות שום תו גלוי במקום אחר.
האם המסביר יכול להתמודד עם ההסתכלות קדימה ולהסתכל מאחור?
כן. מבט חיובי ושלילי קדימה, כתוב (?=...) ו-(?!...), ומבט חיובי ושלילי מאחור, כתוב (?<=...) ו-(?<!...), כל אחד מסומן במה שהוא טוען והם מחורצים כמו קבוצות אחרות. מבט סביב בדוק שהטקסט מופיע או לא מופיע בעמדה מבלי לכלול אותו בהתאמה, שהתיאורים מבהירים.
מדוע המסביר אומר שהדפוס שלי לא חוקי?
התבנית מורכבת עם מנוע ה-RegExp האמיתי לפני שהוא מוסבר, כך שתושבת או סוגריים לא מאוזנים, בריחה לא חוקית או דגל לא ידוע מדווחים עם המנוע 's הודעת שגיאה מדויקת. תקן את הבעיה המדווחת, לרוב סוגריים או סוגר סגירה חסרים, והתקלה תופיע.
האם זה בטוח להדביק regex התואם נתונים פרטיים?
כן הדפוס מנותח כולו ב-JavaScript בתוך הדפדפן שלך הוא אף פעם לא נשלח לשרת, אף פעם לא נרשם, והכלי עובד כשהחיבור שלך מושבת לאחר טעינת הדף אתה יכול להסביר בבטחה דפוסים מבסיסי קוד פרטיים או כאלה התואמים אישית או פורמטים קנייניים.
במה זה שונה מבונה רגקס?
בונה regex עוזר לך לבנות דפוס חדש ממרכיבים ותבניות כשאתה מתחיל מאפס, בעוד המסביר מתאר דפוס שכבר יש לך. השניים משלימים: בנה דפוס עם בונה Regex, הבן דפוס קיים עם המסביר, ואשר אחד מהם כנגד קלט אמיתי עם בודק Regex.
קרא את הדפוסים שלך בחינם מסביר regex. זה מפרק ביטוי רגולרי אסימון אחר אסימון באנגלית פשוטה, כולו בדפדפן שלך, בלי שום דבר שהועלה.
