เราขอนำเสนอคำแปลคำแนะนำสั้นๆ เกี่ยวกับนิพจน์ทั่วไปในภาษา Java ซึ่งเขียนโดย Jeff Friesen สำหรับเว็บไซต์
javaworld เพื่อความสะดวกในการอ่าน เราได้แบ่งบทความออกเป็นหลายส่วน
นิพจน์ทั่วไปใน Java ตอนที่ 1
การรวมหลายช่วง
คุณสามารถรวมหลายช่วงเป็นคลาสอักขระช่วงเดียวได้โดยการวางไว้เคียงข้างกัน ตัวอย่างเช่น คลาส[a-zA-Z]
จะจับคู่อักขระตัวอักษรละตินทั้งหมดโดยใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่
การรวมหลายช่วง คุณสามารถรวมหลายช่วงเป็นคลาสอักขระช่วงเดียวได้โดยการวางไว้เคียงข้างกัน ตัวอย่างเช่น คลาส
[a-zA-Z]
จะจับคู่อักขระตัวอักษรละตินทั้งหมดโดยใช้ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่
การรวมคลาสตัวละคร การรวมคลาสอักขระประกอบด้วยคลาสอักขระที่ซ้อนกันหลายคลาส และจับคู่อักขระทั้งหมดในการรวมคลาสผลลัพธ์ ตัวอย่างเช่น คลาส
[a-d[m-p]]
จะจับคู่อักขระจาก
a
ถึง
d
และจาก
m
ถึง
p
พิจารณาตัวอย่างต่อไปนี้: ตัวอย่าง นี้
java RegexDemo [ab[c-e]] abcdef
จะค้นหาอักขระ
a
,
b
,
c
และซึ่งมีข้อมูลที่ตรงกันใน:
d
e
abcdef
regex = [ ab[ c- e] ]
input = abcdef
Found [ a] starting at 0 and ending at 0
Found [ b] starting at 1 and ending at 1
Found [ c] starting at 2 and ending at 2
Found [ d] starting at 3 and ending at 3
Found [ e] starting at 4 and ending at 4
สี่แยกคลาสตัวละคร จุดตัดกันของคลาสอักขระประกอบด้วยอักขระทั่วไปสำหรับคลาสที่ซ้อนกันทั้งหมด และจับคู่เฉพาะอักขระทั่วไปเท่านั้น ตัวอย่างเช่น คลาสจะ จับ คู่
[a-z&&[d-f]]
อักขระ
d
และ พิจารณาตัวอย่างต่อไปนี้: โปรดทราบว่าบนระบบปฏิบัติการ Windows ของฉัน ต้องใช้เครื่องหมายคำพูดคู่เนื่องจากเชลล์คำสั่งถือว่าเครื่องหมายคำพูดเหล่านั้นเป็นตัวคั่นคำสั่ง ตัวอย่างนี้จะค้นหาเฉพาะอักขระที่ตรงกันใน:
e
f
java RegexDemo "[aeiouy&&[y]]" party
&
y
party
regex = [ aeiouy&& [ y] ]
input = party
Found [ y] starting at 4 and ending at 4
การลบคลาสอักขระ การลบคลาสอักขระประกอบด้วยอักขระทั้งหมด ยกเว้นอักขระที่มีอยู่ในคลาสอักขระที่ซ้อนกัน และจับคู่เฉพาะอักขระที่เหลือเท่านั้น ตัวอย่างเช่น คลาส
[a-z&&[^m-p]]
จะจับคู่อักขระจาก
a
ถึง
l
และ จาก
q
ถึง
z
:
java RegexDemo "[a-f&&[^a-c]&&[^e]]" abcdefg
ตัวอย่างนี้จะค้นหาอักขระ
d
และ
f
มีรายการที่ตรงกันใน
abcdefg
:
regex = [ a- f&& [ ^ a- c] && [ ^ e] ]
input = abcdefg
Found [ d] starting at 3 and ending at 3
Found [ f] starting at 5 and ending at 5
คลาสตัวละครที่กำหนดไว้ล่วงหน้า คลาสอักขระบางตัวปรากฏบ่อยครั้งเพียงพอใน
นิพจน์ทั่วไป เพื่อยืนยันการใช้สัญลักษณ์ชวเลข คลาส
Pattern
นำเสนอคลาสอักขระที่กำหนดไว้ล่วงหน้าเป็นตัวย่อดังกล่าว คุณสามารถใช้เพื่อทำให้นิพจน์ทั่วไปของคุณง่ายขึ้นและลดข้อผิดพลาดทางไวยากรณ์ให้เหลือน้อยที่สุด คลาสอักขระที่กำหนดไว้ล่วงหน้ามีหลายประเภท ได้แก่
java.lang.Character
คุณสมบัติมาตรฐาน POSIX และ Unicode เช่น สคริปต์ บล็อก หมวดหมู่ และไบนารี รายการต่อไปนี้แสดงเฉพาะหมวดหมู่ของคลาสมาตรฐาน:
\d
: ตัวเลข. เทียบเท่า[0-9]
.
\D
: อักขระที่ไม่ใช่ตัวเลข เทียบเท่า[^0-9]
.
\s
: อักขระช่องว่าง เทียบเท่า[ \t\n\x0B\f\r]
.
\S
: ไม่ใช่อักขระช่องว่าง เทียบเท่า[^\s]
.
\w
: สัญลักษณ์สร้างคำ เทียบเท่า[a-zA-Z_0-9]
.
\W
: ไม่ใช่ตัวละครที่สร้างคำ เทียบเท่า[^\w]
.
ตัวอย่างต่อไปนี้ใช้คลาสอักขระที่กำหนดไว้ล่วงหน้า
\w
เพื่ออธิบายอักขระคำทั้งหมดในข้อความอินพุต:
java RegexDemo \w "aZ.8 _"
ดูผลการดำเนินการต่อไปนี้อย่างใกล้ชิด ซึ่งแสดงว่าอักขระจุดและช่องว่างไม่ถือเป็นอักขระคำ:
regex = \w
input = aZ. 8 _
Found [ a] starting at 0 and ending at 0
Found [ Z ] starting at 1 and ending at 1
Found [ 8 ] starting at 3 and ending at 3
Found [ _] starting at 5 and ending at 5
ตัวคั่นบรรทัด
เอกสารประกอบคลาส SDK Pattern
อธิบาย dot meta character ว่าเป็นคลาสอักขระที่กำหนดไว้ล่วงหน้าซึ่งตรงกับอักขระใดๆ ยกเว้นตัวคั่นบรรทัด (ลำดับอักขระหนึ่งหรือสองตัวที่ทำเครื่องหมายจุดสิ้นสุดของบรรทัด) ข้อยกเว้นคือโหมด dotall (ซึ่งเราจะพูดถึงต่อไป) ซึ่งจุดจะจับคู่ตัวคั่นบรรทัดด้วย ชั้นเรียนPattern
แยกแยะตัวคั่นบรรทัดต่อไปนี้:
อักขระขึ้นบรรทัดใหม่ ( \r
);
อักขระขึ้นบรรทัดใหม่ (สัญลักษณ์สำหรับเลื่อนกระดาษหนึ่งบรรทัด) ( \n
);
อักขระขึ้นบรรทัดใหม่ตามด้วยอักขระขึ้นบรรทัดใหม่ทันที ( \r\n
);
อักขระบรรทัดถัดไป ( \u0085
);
อักขระตัวคั่นบรรทัด ( \u2028
);
สัญลักษณ์คั่นย่อหน้า ( \u2029
)
กลุ่มที่ถูกจับ กลุ่มการจับภาพใช้เพื่อบันทึกชุดอักขระที่พบเพื่อใช้เพิ่มเติมเมื่อค้นหาตามรูปแบบ โครงสร้างนี้เป็นลำดับของอักขระที่อยู่ในวงเล็บเมตา (
( )
) อักขระทั้งหมดภายในกลุ่มที่ถูกจับจะถือเป็นอักขระตัวเดียวเมื่อค้นหาตามรูปแบบ ตัวอย่างเช่น กลุ่มการจับ (
Java
) จะรวมตัวอักษร
J
,
a
,
v
และ
a
ให้เป็นหน่วยเดียว กลุ่มแคปเจอร์นี้จะค้นหารูปแบบที่เกิดขึ้นทั้งหมด
Java
ในข้อความอินพุต ในการจับคู่แต่ละครั้ง อักขระที่เก็บไว้ก่อน หน้านี้
Java
จะถูกแทนที่ด้วยอักขระถัดไป กลุ่มที่ถูกจับสามารถซ้อนอยู่ภายในกลุ่มที่ถูกจับอื่นๆ ได้ ตัวอย่างเช่น ในนิพจน์ทั่วไปกลุ่ม
(Java( language))
จะ
(language)
ซ้อนอยู่ภายในกลุ่ม
(Java)
แต่ละกลุ่มการดักจับแบบซ้อนหรือไม่ซ้อนกันจะถูกกำหนดหมายเลข โดยเริ่มจาก 1 และลำดับเลขจะเรียงจากซ้ายไปขวา ในตัวอย่างก่อนหน้านี้
(Java( language))
จับคู่การจับหมายเลขกลุ่ม 1 และ
(language)
ตรงกับกลุ่มการจับหมายเลข 2 ในนิพจน์ทั่วไป จับ คู่
(a)(b)
การ
(a)
จับคู่หมายเลขกลุ่มการจับ 1 และ
(b)
กลุ่มการจับหมายเลข 2
การจับคู่ที่จัดเก็บโดยกลุ่มการจับสามารถเข้าถึงได้ในภายหลังโดยใช้การอ้างอิงย้อนกลับ ระบุเป็นอักขระแบ็กสแลชตามด้วยอักขระตัวเลขที่สอดคล้องกับหมายเลขของกลุ่มที่ถูกจับ การอ้างอิงย้อนกลับทำให้คุณสามารถอ้างอิงถึงอักขระในข้อความที่กลุ่มจับได้ การมีลิงก์ย้อนกลับทำให้ตัวจับคู่อ้างอิงถึงผลการค้นหาที่จัดเก็บไว้ของกลุ่มที่บันทึกไว้ตามหมายเลขจากนั้นใช้อักขระจากผลลัพธ์นั้นเพื่อพยายามค้นหาเพิ่มเติม ตัวอย่างต่อไปนี้แสดงการใช้การอ้างอิงย้อนกลับเพื่อค้นหาข้อผิดพลาดทางไวยากรณ์ในข้อความ:
java RegexDemo "(Java( language)\2)" "The Java language language"
ตัวอย่างนี้
(Java( language)\2)
ใช้นิพจน์ทั่วไปเพื่อค้นหาข้อผิดพลาดทางไวยากรณ์ที่มีคำที่ซ้ำกัน
language
ตามหลัง
Java
ในข้อความที่ป้อน
"The Java language language"
ทันที นิพจน์ทั่วไปนี้ระบุสองกลุ่มที่จะจับ: หมายเลข 1 –
(Java( language)\2)
สอดคล้องกับ
Java language language
และหมายเลข 2 –
(language)
สอดคล้องกับอักขระช่องว่างตาม
language
ด้วย การอ้างอิงย้อนกลับ
\2
ช่วยให้สามารถกลับมาเยี่ยมชมผลลัพธ์ที่เก็บไว้ของกลุ่มหมายเลข 2 ได้อีกครั้ง เพื่อให้ผู้จับคู่สามารถค้นหาการเกิดขึ้นครั้งที่สองของช่องว่าง ตามด้วย
language
ทันทีหลังจากการเกิดขึ้นครั้งแรกของช่องว่าง
language
และ ผลการแข่งขัน
RegexDemo
มีดังนี้:
regex = ( Java ( language) \2 )
input = The Java language language
Found [ Java language language] starting at 4 and ending at 25
ตัวจับคู่ขอบเขต บางครั้งคุณจำเป็นต้องดำเนินการจับคู่รูปแบบที่จุดเริ่มต้นของบรรทัด ที่ขอบเขตคำ ที่ท้ายข้อความ ฯลฯ คุณสามารถทำได้โดยใช้ class edge matcher ตัวใดตัวหนึ่ง
Pattern
ซึ่งเป็นโครงสร้างนิพจน์ทั่วไปที่ค้นหารายการที่ตรงกันในตำแหน่งต่อไปนี้:
^
: จุดเริ่มต้นของบรรทัด;
$
: สิ้นสุดบรรทัด;
\b
: ขอบเขตของคำ;
\B
: ขอบเขตคำนามแฝง;
\A
: เริ่มต้นข้อความ;
\G
: จบการแข่งขันนัดที่แล้ว;
\Z
: ท้ายข้อความ ไม่รวมตัวคั่นบรรทัดต่อท้าย (ถ้ามี)
\z
: สิ้นสุดข้อความ
ตัวอย่างต่อไปนี้ใช้
^
meta character ของตัวจับคู่ขอบเขตเพื่อค้นหาบรรทัดที่ขึ้นต้นด้วย
The
ตามด้วยอักขระคำเป็นศูนย์หรือมากกว่า:
java RegexDemo "^The\w*" Therefore
อักขระ
^
ระบุว่าอักขระสามตัวแรกของข้อความอินพุตต้องตรงกับอักขระรูปแบบที่ต่อเนื่องกัน
T
และ
h
ซึ่ง
e
สามารถตามหลังด้วยตัวเลขใดก็ได้ ของสัญลักษณ์ที่สร้างคำ นี่คือผลลัพธ์ของการดำเนินการ:
regex = ^ The \w*
input = Therefore
Found [ Therefore ] starting at 0 and ending at 8
จะเกิดอะไรขึ้นหากคุณเปลี่ยนบรรทัดคำสั่งเป็น
java RegexDemo "^The\w*" " Therefore"
? จะไม่พบรายการที่ตรงกันเนื่องจาก
Therefore
ข้อความที่ป้อนนำหน้าด้วยอักขระเว้นวรรค
การจับคู่ที่มีความยาวเป็นศูนย์ บางครั้ง เมื่อทำงานกับ Edge Matcher คุณจะพบกับการจับคู่ที่มีความยาวเป็นศูนย์
Совпадение нулевой длины
คือการจับคู่ที่ไม่มีอักขระใดๆ สิ่งเหล่านี้สามารถเกิดขึ้นได้ในข้อความอินพุตที่ว่างเปล่า ที่จุดเริ่มต้นของข้อความอินพุต หลังอักขระสุดท้ายของข้อความอินพุต และระหว่างอักขระสองตัวใดๆ ของข้อความอินพุต การแข่งขันที่มีความยาวเป็นศูนย์นั้นง่ายต่อการจดจำเนื่องจากการแข่งขันจะเริ่มต้นและสิ้นสุดที่ตำแหน่งเดียวกันเสมอ พิจารณาตัวอย่างต่อไปนี้:
java RegExDemo \b\b "Java is"
ตัวอย่างนี้ค้นหาขอบเขตคำสองขอบเขตที่ต่อเนื่องกัน และผลลัพธ์จะมีลักษณะดังนี้:
regex = \b\b
input = Java is
Found [ ] starting at 0 and ending at - 1
Found [ ] starting at 4 and ending at 3
Found [ ] starting at 5 and ending at 4
Found [ ] starting at 7 and ending at 6
เราเห็นการแข่งขันที่มีความยาวเป็นศูนย์หลายครั้งในผลลัพธ์ ตำแหน่งสิ้นสุดที่นี่น้อยกว่าตำแหน่งเริ่มต้นหนึ่งตำแหน่ง เนื่องจาก
RegexDemo
ฉันได้ระบุไว้ในซอร์สโค้ดในรายการ
end() – 1
1
ปริมาณ ปริมาณคือโครงสร้างนิพจน์ทั่วไปที่เชื่อมโยงรูปแบบกับค่าตัวเลขอย่างชัดเจนหรือโดยปริยาย ค่าตัวเลขนี้จะกำหนดจำนวนครั้งในการค้นหารูปแบบ ตัวระบุปริมาณแบ่งออกเป็น โลภ ขี้เกียจ และโลภมาก:
ตัวระบุปริมาณโลภ ( ?
, *
หรือ+
) ได้รับการออกแบบมาเพื่อค้นหาคู่ที่ยาวที่สุด ฉันถามได้ไหมX
? เพื่อค้นหาหนึ่งหรือน้อยกว่าX
เพื่อX*
ค้นหาการเกิดเป็นศูนย์หรือมากกว่าX
เพื่อX+
ค้นหาหนึ่งหรือหลายเหตุการณ์X
เพื่อX{n}
ค้นหาn
การเกิดX
เพื่อX{n,}
ค้นหาอย่างน้อย (และอาจมากกว่า) เกิดn
ขึ้นX
และX{n,m}
เพื่อค้นหาอย่างน้อยn
แต่ไม่มากกว่าm
นั้นX
Lazy quantifier ( ??
, *?
หรือ+?
) ได้รับการออกแบบมาเพื่อค้นหาค่าที่ตรงกันที่สั้นที่สุด คุณสามารถระบุX??
เพื่อค้นหาเหตุการณ์X
, X*
? เพื่อค้นหาการเกิดเหตุการณ์เป็นศูนย์หรือมากกว่าเพื่อค้นหาเหตุการณ์หนึ่งเหตุการณ์ขึ้นไปการค้นหาการเกิดเหตุการณ์การ ค้นหา เหตุการณ์อย่างน้อย (และอาจมากกว่านั้น) และX
การค้นหาอย่างน้อยแต่ไม่เกินกว่าเหตุการณ์X+?
X
X{n}?
n
X
X{n,}?
n
X
X{n,m}?
n
m
X
ตัวระบุปริมาณโลภมาก ( ?+
, *+
หรือ++
) มีลักษณะคล้ายกับปริมาณโลภมาก ยกเว้นว่าตัวระบุปริมาณโลภมากจะพยายามค้นหารายการที่ตรงกันที่ยาวที่สุดเท่านั้น ในขณะที่ตัวปริมาณโลภสามารถพยายามได้หลายครั้ง สามารถตั้งค่าX?+
ให้ค้นหาหนึ่งรายการหรือน้อยกว่าX
เพื่อX*+
ค้นหารายการที่เกิดขึ้นเป็นศูนย์หรือมากกว่า เพื่อค้นหารายการอย่างน้อยหนึ่งรายการเพื่อค้นหารายการของเพื่อ ค้นหา รายการอย่างน้อย (และอาจมากกว่า) X
รายการและเพื่อค้นหารายการอย่างน้อยแต่ไม่เกินรายการ.X++
X
X{n}+
n
X
X{n,}+
n
X
X{n,m}+
n
m
X
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการใช้ปริมาณโลภ:
java RegexDemo .*ox "fox box pox"
นี่คือผลลัพธ์:
regex = . *ox
input = fox box pox
Found [ fox box pox] starting at 0 and ending at 10
ตัวระบุปริมาณโลภ (
.*
) ค้นหาลำดับที่ยาวที่สุดของอักขระที่ลงท้าย
ox
ด้วย โดยจะใช้ข้อความที่ป้อนทั้งหมดแล้วย้อนกลับจนกว่าจะตรวจพบว่าข้อความที่ป้อนลงท้ายด้วยอักขระเหล่านี้ พิจารณาปริมาณขี้เกียจตอนนี้:
java RegexDemo .*?ox "fox box pox"
ผลลัพธ์:
regex = . *? ox
input = fox box pox
Found [ fox] starting at 0 and ending at 2
Found [ box] starting at 3 and ending at 6
Found [ pox] starting at 7 and ending at 10
Lazy quantifier (
.*?
) ค้นหาลำดับที่สั้นที่สุดของอักขระที่ลงท้าย
ox
ด้วย เริ่มต้นด้วยสตริงว่างและค่อยๆ ใช้อักขระจนกว่าจะพบรายการที่ตรงกัน จากนั้นทำงานต่อไปจนกว่าข้อความที่ป้อนจะหมด สุดท้าย เรามาดูปริมาณที่โลภมาก:
java RegexDemo .*+ox "fox box pox"
และนี่คือผลลัพธ์:
regex = . *+ ox
input = fox box pox
ตัวระบุปริมาณที่โลภมาก (
.*+
) ไม่พบรายการที่ตรงกันเนื่องจากใช้ข้อความที่ป้อนทั้งหมด และไม่มีสิ่งใดเหลือให้จับคู่
ox
ที่ส่วนท้ายของนิพจน์ทั่วไป ต่างจากตัวปริมาณที่โลภมาก ตัวปริมาณที่โลภมากจะไม่ย้อนกลับ
การจับคู่ที่มีความยาวเป็นศูนย์ บางครั้งเมื่อทำงานกับตัวระบุปริมาณ คุณจะพบกับการจับคู่ที่มีความยาวเป็นศูนย์ ตัวอย่างเช่น การใช้ greedy quantifier ต่อไปนี้จะส่งผลให้เกิดการจับคู่ที่มีความยาวเป็นศูนย์หลายรายการ
java RegexDemo a? abaa
ผลลัพธ์ของการเรียกใช้ตัวอย่างนี้:
regex = a?
input = abaa
Found [ a] starting at 0 and ending at 0
Found [ ] starting at 1 and ending at 0
Found [ a] starting at 2 and ending at 2
Found [ a] starting at 3 and ending at 3
Found [ ] starting at 4 and ending at 3
มีการแข่งขันห้านัดในผลการดำเนินการ แม้ว่าตัวแรก สาม และสี่นั้นค่อนข้างคาดหวัง (ตรงกับตำแหน่งของตัวอักษรสามตัว
a
ใน
abaa
) แต่ตัวที่สองและห้าอาจทำให้คุณประหลาดใจ ดูเหมือนว่าพวกเขาจะระบุสิ่งที่
a
สอดคล้อง
b
กับส่วนท้ายของข้อความ แต่ในความเป็นจริงแล้วไม่เป็นเช่นนั้น นิพจน์ทั่วไป
a?
ไม่ค้นหา
b
ที่ส่วนท้ายของข้อความ มันค้นหาว่ามีหรือ
a
ไม่มี เมื่อ
a?
ไม่พบ
a
ระบบจะรายงานว่าเป็นการจับคู่ที่มีความยาวเป็นศูนย์
นิพจน์แฟล็กที่ซ้อนกัน ตัวจับคู่สร้างสมมติฐานเริ่มต้นบางอย่างที่สามารถแทนที่ได้เมื่อรวบรวมนิพจน์ทั่วไปเป็นรูปแบบ เราจะหารือเกี่ยวกับปัญหานี้ในภายหลัง นิพจน์ทั่วไปช่วยให้คุณสามารถแทนที่ค่าเริ่มต้นใดๆ ได้โดยใช้นิพจน์แฟล็กที่ซ้อนกัน โครงสร้างนิพจน์ทั่วไปนี้ระบุเป็นอักขระเมตาของวงเล็บรอบอักขระเมตาเครื่องหมายคำถาม (
?
) ตามด้วยตัวอักษรละตินตัวพิมพ์เล็ก ชั้น
Pattern
เข้าใจนิพจน์ธงที่ซ้อนกันต่อไปนี้:
(?i)
: เปิดใช้งานการจับคู่รูปแบบที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ตัวอย่างเช่น เมื่อใช้คำสั่งjava RegexDemo (?i)tree Treehouse
ลำดับของอักขระTree
จะตรงกับรูปtree
แบบ ค่าเริ่มต้นคือการค้นหารูปแบบที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
(?x)
: อนุญาตให้ใช้อักขระช่องว่างและความคิดเห็นที่ขึ้นต้นด้วยอักขระเมตาภายในรูป#
แบบ ผู้จับคู่จะไม่สนใจทั้งสองอย่าง ตัวอย่างเช่น สำหรับjava RegexDemo ".at(?x)#match hat, cat, and so on" matter
ลำดับอักขระmat
ที่ตรงกับรูป.at
แบบ ตามค่าเริ่มต้น ไม่อนุญาตให้ใช้อักขระช่องว่างและความคิดเห็น และผู้จับคู่จะถือว่าอักขระเหล่านั้นเป็นอักขระที่เกี่ยวข้องกับการค้นหา
(?s)
: เปิดใช้งานโหมด dotall ซึ่งอักขระ dot meta จะจับคู่ตัวคั่นบรรทัด นอกเหนือจากอักขระอื่นๆ เช่น คำสั่งjava RegexDemo (?s). \n
จะค้นหาอักขระขึ้นบรรทัดใหม่ ค่าเริ่มต้นจะตรงกันข้ามกับ dotall: ไม่พบตัวคั่นบรรทัด ตัวอย่างเช่น คำสั่งJava RegexDemo . \n
จะไม่พบอักขระขึ้นบรรทัดใหม่
(?m)
: เปิดใช้งานโหมดหลายบรรทัด โดยจะ^
ตรงกับจุดเริ่มต้นและ$
จุดสิ้นสุดของแต่ละบรรทัด ตัวอย่างเช่นjava RegexDemo "(?m)^abc$" abc\nabc
ค้นหาทั้งสองลำดับในข้อความที่abc
ป้อน ตามค่าเริ่มต้น จะใช้โหมดบรรทัดเดียว: ^
จับคู่จุดเริ่มต้นของข้อความที่ป้อนทั้งหมด และ$
จับคู่ส่วนท้ายของข้อความ ตัวอย่างเช่นjava RegexDemo "^abc$" abc\nabc
ส่งคืนการตอบกลับว่าไม่มีรายการที่ตรงกัน
(?u)
: เปิดใช้งานการจัดตำแหน่งตัวพิมพ์ที่ละเอียดอ่อนของ Unicode ธงนี้ เมื่อใช้ร่วมกับ(?i)
จะอนุญาตให้มีการจับคู่รูปแบบที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ตามมาตรฐาน Unicode การตั้งค่าเริ่มต้นคือการค้นหาอักขระที่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่และ US-ASCII เท่านั้น
(?d)
: เปิดใช้งานโหมดสตริงสไตล์ Unix โดยที่ตัวจับคู่จะจดจำอักขระเมตาในบริบท.
และ^
เฉพาะตัว$
คั่นบรรทัด\n
เท่านั้น ค่าเริ่มต้นคือโหมดสตริงสไตล์ที่ไม่ใช่ Unix: ตัวจับคู่จะจดจำตัวคั่นบรรทัดทั้งหมดในบริบทของอักขระเมตาข้างต้น
นิพจน์แฟล็กที่ซ้อนกันมีลักษณะคล้ายกับกลุ่มที่บันทึกไว้เนื่องจากอักขระของพวกเขาถูกล้อมรอบด้วยอักขระเมตาในวงเล็บ ต่างจากกลุ่มที่บันทึก นิพจน์แฟล็กที่ซ้อนกันเป็นตัวอย่างของกลุ่มที่ไม่ได้บันทึก ซึ่งเป็นโครงสร้างนิพจน์ทั่วไปที่ไม่บันทึกอักขระข้อความ ถูกกำหนดให้เป็นลำดับของอักขระที่ล้อมรอบด้วย meta character ของวงเล็บ
การระบุนิพจน์แฟล็กที่ซ้อนกันหลายรายการ
คุณสามารถระบุนิพจน์แฟล็กที่ซ้อนกันหลายรายการในนิพจน์ทั่วไปได้โดยการวางไว้เคียงข้างกัน ( (?m)(?i))
) หรือวางตัวอักษรที่กำหนดตามลำดับ ( (?mi)
)
บทสรุป ดังที่คุณคงทราบแล้วว่านิพจน์ทั่วไปมีประโยชน์อย่างยิ่งและมีประโยชน์มากยิ่งขึ้นเมื่อคุณเชี่ยวชาญความแตกต่างของไวยากรณ์ จนถึงตอนนี้ ฉันได้แนะนำให้คุณรู้จักกับพื้นฐานของนิพจน์ทั่วไป
Pattern
และ ในส่วนที่ 2 เราจะเจาะลึกลงไปใน Regex API และสำรวจวิธีการของ
Pattern
,
Matcher
และ
PatternSyntaxException
. นอกจากนี้ ฉันจะแสดงแอปพลิเคชัน Regex API ที่ใช้งานได้จริงสองแอปพลิเคชันให้คุณดู ซึ่งคุณสามารถใช้ในโปรแกรมของคุณได้ทันที
นิพจน์ทั่วไปใน Java ส่วนที่ 3 นิพจน์ทั่วไปใน Java ส่วนที่ 4 นิพจน์ทั่วไปใน Java ส่วนที่ 5
GO TO FULL VERSION