ביטוי רגולרי הוא מעין דפוס שניתן להחיל על טקסט (String, ב-Java). Java מספקת את חבילת
java.util.regex להתאמת ביטויים רגולריים. ביטויים רגולריים דומים מאוד לשפת התכנות Perl וקל מאוד ללמוד אותם. ביטוי רגולרי מתאים לטקסט (חלק ממנו) או לא. * אם ביטוי רגולרי מתאים לפיסת טקסט, נוכל למצוא אותו. ** אם הביטוי הרגולרי מורכב, אז נוכל להבין בקלות איזה חלק של הביטוי הרגולרי מתאים לאיזה חלק בטקסט.
דוגמה ראשונה
הביטוי הרגולרי "
[a-z] +
" מתאים לכל האותיות הקטנות בטקסט.
[a-z]
פירושו כל תו מ-
a
עד
z
כולל,
+
ופירושו תו "אחד או יותר". נניח שאנו מספקים את המחרוזת "קוד 2 למד מדריך ג'אווה". כיצד לעשות זאת ב-Java ראשית, עליך ליצור תבנית:
import java.util.regex.*;
Pattern p = Pattern.compile(“[a-z]+”);
לאחר מכן עליך ליצור
matcher
עבור הטקסט על ידי שליחת הודעה בתרשים:
Matcher m = p.matcher(“code 2 learn java tutorial”);
הערה: גם אין בנאים
Pattern
,
Matcher
אנו יוצרים אותם באמצעות שיטות מחלקות
Pattern
.
Pattern Class:
אובייקט המחלקה מהווה ייצוג של ביטוי רגולרי. המחלקה Pattern אינה מספקת בנאים ציבוריים. כדי ליצור תבנית, תחילה עליך לקרוא לאחת מהשיטות הסטטיות הציבוריות, אשר לאחר מכן מחזירות אובייקט של המחלקה
Pattern
. שיטות אלה לוקחות ביטוי רגולרי כטיעון.
Matcher Class:
אובייקט Finder הוא מנוע שמפרש את התבנית ומבצע פעולות התאמה במחרוזת הקלט. כמו
Pattern
כיתה,
Matcher
אין לה בנאים ציבוריים. אתה מקבל אובייקט
Matcher
על ידי קריאה למתודה
matcher
על אובייקט מחלקה
Pattern
. לאחר שהשלמנו את השלבים הללו, וכעת יש לנו מופע של המחלקה
Matcher m
, כעת נוכל לבדוק האם התבנית נמצאה או לא, ואם כן, באיזה מיקום וכו'.
m.matches()
מחזירה true אם התבנית תואמת לכל המחרוזת, אחרת false.
m.lookingAt()
מחזירה true אם התבנית תואמת לתחילת המחרוזת, אחרת false.
m.find ()
מחזירה true אם התבנית תואמת לחלק כלשהו בטקסט.
מציאת התאמה
לאחר התאמה מוצלחת,
m.start() יחזיר את האינדקס של התו הראשון המותאם ו-
m.end() יחזיר את האינדקס של התו האחרון המותאם, פלוס אחד. אם נעשה ניסיון לא מוצלח ולא נמצאה התאמה,
m.start()
הם
m.end()
יזרקו
IllegalStateException
- זה
RuntimeException
כדי שלא תצטרך לתפוס את זה.
זה אולי נראה מוזר להחזיר
m.end()
את האינדקס של התו האחרון התואם פלוס אחד, אבל זה בדיוק מה שרוב ה-
String
.
- לדוגמה,
“Now is the time“.substring(m.start(), m.end())
יחזיר את אותה מחרוזת. בואו נסתכל על הקוד:
import java.util.regex.*;
public class RegexTest {
public static void main(String args[]) {
String pattern = "[a-z]+";
String text = "code 2 learn java tutorial";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);
while(m.find()) {
System.out.print(text.substring(m.start(), m.end()) + "*");
}
}
}
Output: code*learn*java*tutorial*
שיטות נוספות
אם יש התאמה, אז:
m.replaceFirst(replacement)
מחזירה מחרוזת חדשה, שבה תת המחרוזת הראשונה שתתאים לתבנית תוחלף בreplacement
m.replaceAll(replacement)
מחזיר מחרוזת חדשה, שבה כל תת-מחרוזת שתתאים לתבנית תוחלף
m.find(StartIndex)
מצא את ההתאמה הבאה החל מהאינדקס שצוין
m.reset()
מאפס את התבנית
m.reset(NewText)
מאפס את המאתר ונותן לו טקסט חדש (אולי String
, StringBuffer
או CharBuffer
)
תחביר ביטוי רגולרי
^
מתאים לתחילת שורה.
$
מתאים לקצה המחרוזת.
.
מתאים לכל תו בודד מלבד שורה חדשה. שימוש באפשרות m מאפשר לה להתאים שורה חדשה.
[...]
מתאים לכל תו בודד בסוגריים.
[^ ...]
מתאים לכל תו בודד שלא בסוגריים.
\A
התחל את כל הקו.
\z
סוף שורה שלמה.
\Z
סוף השורה כולה מלבד מסיים הקו האחרון.
re*
תואם 0 או יותר מופעים של הביטוי הקודם.
re+
התאמה אחת או יותר של הביטוי הקודם.
re?
מתאים 0 או 1 למיקום הביטוי הקודם.
re{n}
מתאים בדיוק ל-N מספר המופעים של הביטוי הקודם.
re{n,}
מתאים ל-N או יותר מופעים של הביטוי הקודם.
re{n, m}
תואם לפחות n ולכל היותר m מופעים של הביטוי הקודם.
a|b
מתאים ל-a או ב.
(re)
קבוצה של ביטויים רגולריים וזכירת הטקסט שנמצא.
(?: re)
קבוצות של ביטויים רגולריים שאינם זוכרים את הטקסט שנמצא.
(?> re)
מתאים לתבנית עצמאית ללא החזרות.
\w
מתאים אותיות ומספרים [a-zA-Z_0-9].
\W
אלו לא אותיות או מספרים.
\s
תואם רווחים. שווה ערך ל-[\t\n\r\f].
\S
לא תווי רווח לבן.
\d
תואם את המספרים. שווה ערך ל-[0-9].
\D
לא תואם את המספרים.
\G
תואם את הנקודה של המשחק האחרון.
\n
תואם קו חדש.
\b
התאמות בגבול מילים.
\B
התאמה לא על גבול מילה.
\n, \t, etc.
תווים בשורה חדשה, החזרת כרכרה, טאב וכו'.
\Q
צטט את כל התווים לפני \E.
\E
הציטוט התחיל ב-\Q מסתיים.
GO TO FULL VERSION