Regex หรือนิพจน์ทั่วไปเป็นสิ่งที่น่ากลัวสำหรับผู้เริ่มต้น แต่จำเป็นสำหรับโปรแกรมเมอร์ทุกคน มาทำความเข้าใจนิพจน์ทั่วไปโดยใช้ 5 ตัวอย่างง่ายๆ กับ JavaScript กันดีกว่า
หากคุณมีปัญหาและกำลังจะแก้ไขด้วยนิพจน์ทั่วไป ตอนนี้คุณมีปัญหาสองข้อ มีคำกล่าวว่า. นิพจน์ทั่วไปที่พบในโค้ดบางครั้งทำให้เกิดความกลัวและความเกลียดชังในคนที่ไม่คุ้นเคย
แต่ในความเป็นจริงแล้ว regex ใดๆ เป็นเพียงนิพจน์เทมเพลตที่สามารถแก้ปัญหาของฟังก์ชันทั้งหมดในบรรทัดเดียวได้ อย่างไรก็ตาม ในการสร้างนิพจน์ทั่วไป คุณต้องคำนึงถึงกฎที่เข้มงวดซึ่งผู้เริ่มต้นอาจสับสนและทำผิดพลาดได้
อักขระที่ตรงกันนิพจน์ทั่วไปพื้นฐานที่สุดคือนิพจน์ที่ตรงกับอักขระตัวเดียว นี่คือกฎของพวกเขา:
1. จุด (.) ตรงกับอักขระใดๆ หากคุณต้องการค้นหาจุดใดจุดหนึ่ง คุณต้องหลีกเลี่ยงจุดนั้นโดยใช้อักขระ “\” (\.)
2. เครื่องหมายคำถาม (?) ระบุว่าอักขระก่อนหน้าเป็นทางเลือก หากต้องการค้นหาเครื่องหมายคำถามในสตริง จะต้อง Escape ด้วย "\" (\?)
var text = "Lorem ipsum dolor นั่ง amet, consectetur adipiscing elit เกรงว่า Donec convallis dignissim ligula, et rutrum est elat vistibulum eu"; // ทั้ง "elit" และ "elat" จะทำ จุดหมายถึงสิ่งนั้น จะทำอะไรก็ได้เครื่องหมาย. var regex = /el.t/g; console.log(text.match(regex)); // "est" และ "lest" จะทำงานได้ดีพอๆ กัน เครื่องหมายคำถามทำให้ "l" เป็นทางเลือก var regex2 = /l?est/g; console.log(text.match(regex2));
var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit เกรงว่า Donec convallis dignissim ligula, et rutrum est elat vistibulum eu" - // ทั้ง "elit" และ "elat" จะทำ จุดหมายถึงสัญลักษณ์ใดก็ได้ var regex = /el.t/g ; คอนโซล เข้าสู่ระบบ(text.match(regex)); // "est" และ "lest" จะทำงานได้ดีพอๆ กัน เครื่องหมายคำถามทำให้ "l" เป็นทางเลือก var regex2 = /l?est/g ; คอนโซล เข้าสู่ระบบ (text.match (regex2)); |
ชุดคืออักขระตั้งแต่หนึ่งตัวขึ้นไปที่อยู่ในวงเล็บ เช่น นิพจน์ดังกล่าวจะค้นหาเฉพาะชุดอักขระนี้ในสตริง - อิน ในตัวอย่างนี้เพียง a, b หรือ c ในทางตรงกันข้าม คุณสามารถค้นหาสัญลักษณ์ใดๆ ที่เกิดขึ้นได้ ยกเว้นการใช้สัญลักษณ์ “^” [^abc] จะจับคู่อักขระใดๆ ที่ไม่ใช่ a, b หรือ c คุณยังสามารถระบุช่วงของอักขระหรือตัวเลขได้ เช่น
มีชุดอักขระในตัวที่ช่วยให้เขียนนิพจน์ทั่วไปได้ง่ายขึ้น พวกเขาเรียกว่าคำย่อหรือชวเลข ตัวอย่างเช่น คุณสามารถเขียน \D แทนได้ มีคำย่อสำหรับอักขระอื่นๆ (รวมถึงตัวเลขและขีดล่าง) - \w และ \W รวมถึงการเว้นวรรค - \s และ \S
// เฉพาะ "cat" และ "can" เท่านั้นที่จะใช้งานได้ ไม่ใช่ "car" var text = "รถแมวสามารถ"; console.log(text.match(/ca/g)); // ทุกอย่างจะผ่านไป ยกเว้น cat และ can (มีสัญลักษณ์ ^) console.log(text.match(/ca[^tn]/g)); // อีกตัวอย่างหนึ่งที่เฉพาะตัวเลขเท่านั้นที่จะส่งข้อความ = "ฉันต้องการกาแฟ 8 ถ้วยโปรด"; console.log("กี่ถ้วย: " + text.match(//g)); // วิธีที่ง่ายกว่าโดยใช้ทางลัด \d console.log("กี่ถ้วย: " + text.match(/\d/g)); // ส่งผ่านทุกอย่างยกเว้นตัวเลข console.log(text.match(/\D/g));
// เฉพาะ "cat" และ "can" เท่านั้นที่จะใช้งานได้ ไม่ใช่ "car" var text = "รถแมวสามารถ" ; คอนโซล เข้าสู่ระบบ(text.match(/ca/g)); // ผ่านทุกอย่าง ยกเว้น cat และ can (มีสัญลักษณ์ ^) คอนโซล บันทึก (ข้อความ . ตรง (/ca[^tn]/g ) ) ; // อีกตัวอย่างหนึ่งที่จะผ่านเฉพาะตัวเลขเท่านั้น text = "ฉันขอกาแฟ 8 แก้วค่ะ" - คอนโซล log ("กี่ถ้วย: " + text . match (//g ) ) ; // วิธีที่ง่ายกว่าโดยใช้ทางลัด \d คอนโซล log("กี่ถ้วย: " + text .match (/\d/g ) ) ; // ส่งผ่านทุกอย่างยกเว้นตัวเลข คอนโซล บันทึก(text.match(/\D/g)); |
ในกรณีส่วนใหญ่ คุณจะต้องค้นหาทั้งคำมากกว่า ตัวละครแต่ละตัว- ทำได้โดยใช้ตัวแก้ไข (+) และ (-) ซึ่งทำซ้ำอักขระหรือชุดอักขระ
การบวก (X) ระบุจำนวนการซ้ำที่แน่นอน (x, y) – ช่วง (x และ y เป็นตัวเลข)
นอกจากนี้ยังมีรูปแบบพิเศษ \b ที่ตรงกับขอบเขตที่ส่วนท้ายของคำ
var text = "สวัสดีชาวปี 1974 ฉันมาจากอนาคต ในปี 2014 เรามีปืนเลเซอร์ โฮเวอร์บอร์ด และอาศัยอยู่บนดวงจันทร์!"; //จะพบปี. \d+ จะจับคู่อักขระตั้งแต่หนึ่งตัวขึ้นไป var yearRegex = /\d+/g; console.log("ปี: ", text.match(yearRegex)); // ค้นหาประโยคทั้งหมด ประโยคของเราเริ่มต้นด้วยตัวพิมพ์ใหญ่และลงท้ายด้วยจุดหรือเครื่องหมายอัศเจรีย์ var ประโยคRegex = /.+?(\.|!/g; console.log("ประโยค: ", text.match(sentenceRegex)); // ค้นหาคำทั้งหมดที่ขึ้นต้นด้วย "h" ทั้งตัวพิมพ์ใหญ่และตัวพิมพ์เล็กเหมาะสำหรับเรา ดังนั้นเราจึงใช้ตัวแก้ไข i // \b เพื่อกำหนดขอบเขตของคำ var hWords = /\bh\w+/ig; console.log("คำ H: ", text.match(hWords)); // ค้นหาคำทั้งหมดตั้งแต่ 4 ถึง 6 ตัวอักษร var findWords = /\b\w(4,6)\b/g; console.log("คำระหว่าง 4 ถึง 6 ตัวอักษร: ", text.match(findWords)); // ค้นหาคำที่ยาวเกิน 5 ตัวอักษร console.log("คำที่มีความยาว 5 ตัวอักษรขึ้นไป: ", text.match(/\b\w(5,)\b/g)); // ค้นหาคำที่มีความยาว 6 ตัวอักษรพอดี console.log("คำที่มีความยาว 6 ตัวอักษรพอดี: ", text.match(/\b\w(6)\b/g));
var text = "สวัสดีชาวปี 1974 ฉันมาจากอนาคต ในปี 2014 เรามีปืนเลเซอร์ โฮเวอร์บอร์ด และอาศัยอยู่บนดวงจันทร์!" - //จะพบปี. \d+ จับคู่อักขระตั้งแต่หนึ่งตัวขึ้นไป var yearRegex = /\d+/g ; คอนโซล log ( "ปี:" , text .match ( yearRegex ) ) ; // ค้นหาประโยคทั้งหมด ประโยคของเราเริ่มต้นด้วยตัวพิมพ์ใหญ่และลงท้ายด้วยจุดหรือเครื่องหมายอัศเจรีย์ var ประโยคRegex = /.+?(\.|!/g ; คอนโซล log("ประโยค: ", text.match(sentenceRegex)); // ค้นหาคำทั้งหมดที่ขึ้นต้นด้วย "h" ทั้งตัวพิมพ์ใหญ่และตัวพิมพ์เล็กเหมาะสำหรับเรา ดังนั้นเราจึงใช้ตัวปรับแต่ง i // \b เพื่อกำหนดขอบเขตของคำ var hWords = /\bh\w+/ig ; คอนโซล log ( "H Words:" , text .match (hWords ) ) ; // ค้นหาคำทั้งหมดตั้งแต่ 4 ถึง 6 ตัวอักษร var findWords = /\b\w(4,6)\b/g ; คอนโซล log("คำระหว่าง 4 ถึง 6 ตัวอักษร: ", text.match(findWords)); // ค้นหาคำที่ยาวเกิน 5 ตัวอักษร คอนโซล log ("คำ 5 ตัวอักษรขึ้นไป: " , text .match (/\b\w(5,)\b/g ) ) ; // ค้นหาคำที่มีความยาว 6 ตัวอักษรพอดี คอนโซล log ("คำที่มีความยาว 6 ตัวอักษรพอดี: " , text .match (/\b\w(6)\b/g ) ) ; |
ใน JavaScript นิพจน์ดังกล่าวสามารถใช้เพื่อตรวจสอบการป้อนข้อมูลของผู้ใช้จากช่องข้อความ ในการตรวจสอบความถูกต้องของสตริง จะใช้นิพจน์ทั่วไปปกติซึ่งเชื่อมโยงกับจุดเริ่มต้นและจุดสิ้นสุดของส่วนของข้อความ โดยใช้นิพจน์ ^ (จุดเริ่มต้นของบรรทัด) และ $ (สิ้นสุดบรรทัด) เพื่อจุดประสงค์นี้ สัญลักษณ์เหล่านี้ช่วยให้แน่ใจว่ารูปแบบที่คุณเขียนครอบคลุมความยาวทั้งหมดของข้อความ ไม่ใช่แค่ตรงกับบางส่วนเท่านั้น
นอกจากนี้ ในกรณีนี้ เราใช้เมธอด test() ของออบเจ็กต์ regex ซึ่งจะคืนค่าเป็นจริงหรือเท็จเมื่อทดสอบว่านิพจน์ทั่วไปตรงกับสตริงหรือไม่
// เรามีอาร์เรย์ของสตริง ลองค้นหา links..com/", "123461", "https://site/?s=google", "http://not a valid url", "abc http: / /invalid.url/" ]; var regex = /^https?:\/\/[\w\/?.&-=]+$/; var urls = ; for(var i = 0; i< strings.length; i++){ if(regex.test(strings[i])){ // Валидная ссылка urls.push(strings[i]); } } console.log("Valid URLs: ", urls);
// เรามีอาร์เรย์ของสตริง ลองค้นหาลิงก์กัน สตริง var = [ "https://site/" , "นี่ไม่ใช่ URL" "https://google.com/" , "123461" , "https://site/?s=google" , "http://ไม่ใช่ URL ที่ถูกต้อง" , "เอบีซี http://invalid.url/" var regex = / ^ https ? : \ / \ / [ \ w \ / ? - - var url = ; สำหรับ (var i = 0 ; i< strings . length ; i ++ ) { ถ้า (regex . ทดสอบ (สตริง [ i ] ) ) ( URL ผลักดัน (สตริง [i]); คอนโซล log("URL ที่ถูกต้อง: ", urls); |
อื่น งานทั่วไปซึ่งอำนวยความสะดวกโดยการใช้นิพจน์ทั่วไปคือการค้นหาและแทนที่ข้อความ
ตัวดัดแปลงสัญลักษณ์ลบ (-) ที่วางอยู่ถัดจากตัวแก้ไข (ยกเว้น U) จะทำให้เกิดการปฏิเสธ
อักขระพิเศษ| () | รูปแบบย่อย นิพจน์ที่ซ้อนกัน | |
| ไวด์การ์ด | ||
| (ก,ข) | จำนวนครั้งที่เกิดขึ้นจาก "a" ถึง "b" | |
| | | ตรรกะ "หรือ" ในกรณีที่ใช้อักขระตัวเดียว | |
| \ | หลบหนีตัวละครพิเศษ | |
| . | อักขระใดๆ ยกเว้นการป้อนบรรทัด | |
| \d | หลักทศนิยม | |
| \D | [^\ง] | อักขระใดๆ ที่ไม่ใช่เลขทศนิยม |
| \ฉ | สิ้นสุด (ตัวแบ่งหน้า) | |
| \n | ฟีดบรรทัด | |
| \pL | ตัวอักษรในการเข้ารหัส UTF-8 เมื่อใช้ตัวแก้ไข u | |
| \r | การคืนรถ | |
| \s | [\t\v\r\n\f] | อักขระอวกาศ |
| \ส | [^\s] | อักขระใดๆ ยกเว้นตัวที่กะพริบ |
| \t | การจัดตาราง | |
| \w | ตัวเลข ตัวอักษร หรือขีดล่างใดๆ | |
| \ว | [^\w] | อักขระใดๆ ที่ไม่ใช่ตัวเลข ตัวอักษร หรือขีดล่าง |
| \v | แท็บแนวตั้ง |
| ^ | ^ก | อ่าาา | จุดเริ่มต้นของบรรทัด |
| $ | เป็น$ | อ๊าาา | สิ้นสุดบรรทัด |
| \ก | \อ๋า | อ่าาา อ๊าาา | จุดเริ่มต้นของข้อความ |
| \z | ก\z | อ๊าาา อ๊าาา | ท้ายข้อความ |
| \ข | ก\ข \บา | อ๊าาา อ๊า อ๊า | ขอบเขตของคำ คำสั่ง: อักขระก่อนหน้านี้เป็นวาจา แต่อักขระถัดไปไม่ใช่ หรือในทางกลับกัน |
| \บี | \บา\บี | อ๊า อ๊า | ไม่มีขอบเขตของคำว่า |
| \จี | \กา | อ๊าาา | การค้นหาสำเร็จก่อนหน้านี้ การค้นหาหยุดที่ตำแหน่งที่ 4 - โดยไม่พบ a |
จุดยึดในนิพจน์ทั่วไปบ่งบอกถึงจุดเริ่มต้นหรือจุดสิ้นสุดของบางสิ่ง เช่น ประโยคหรือคำพูด พวกเขาจะถูกนำเสนอ อักขระบางตัว- ตัวอย่างเช่น รูปแบบที่ตรงกับสตริงที่ขึ้นต้นด้วยตัวเลขจะมีลักษณะดังนี้:
ในที่นี้อักขระ ^ หมายถึงจุดเริ่มต้นของบรรทัด หากไม่มีรูปแบบก็จะตรงกับสตริงที่มีตัวเลข
คลาสตัวละครคลาสอักขระในนิพจน์ทั่วไปจะจับคู่ชุดอักขระบางชุดพร้อมกัน ตัวอย่างเช่น \d จับคู่ตัวเลขตั้งแต่ 0 ถึง 9 รวม \w จับคู่ตัวอักษรและตัวเลข และ \W จับคู่อักขระทั้งหมดที่ไม่ใช่ตัวอักษรและตัวเลข รูปแบบการระบุตัวอักษร ตัวเลข และการเว้นวรรคมีลักษณะดังนี้:
POSIXPOSIX เป็นส่วนเสริมที่ค่อนข้างใหม่ในกลุ่มนิพจน์ทั่วไป แนวคิด เช่นเดียวกับคลาสอักขระ คือการใช้ทางลัดที่แสดงถึงกลุ่มอักขระบางกลุ่ม
งบเกือบทุกคนมีปัญหาในการทำความเข้าใจคำยืนยันในตอนแรก แต่เมื่อคุณคุ้นเคยกับมันมากขึ้น คุณจะพบว่าตัวเองใช้คำยืนยันเหล่านี้ค่อนข้างบ่อย การยืนยันเป็นวิธีในการพูดว่า “ฉันต้องการค้นหาทุกคำในเอกสารนี้ที่มีตัวอักษร “q” และไม่ตามด้วย “werty”
[^\s]*q(?!werty)[^\s]*
โค้ดด้านบนเริ่มต้นด้วยการค้นหาอักขระอื่นที่ไม่ใช่ช่องว่าง ([^\s]*) ตามด้วย q นักแยกวิเคราะห์ก็มาถึงการยืนยันที่เป็นการคาดการณ์ล่วงหน้า ซึ่งจะทำให้องค์ประกอบที่อยู่ข้างหน้า (อักขระ กลุ่ม หรือคลาสอักขระ) มีเงื่อนไขโดยอัตโนมัติ โดยจะจับคู่รูปแบบก็ต่อเมื่อคำสั่งเป็นจริงเท่านั้น ในกรณีของเรา คำสั่งนั้นเป็นลบ (?!) นั่นคือมันจะเป็นจริงหากไม่พบสิ่งที่กำลังค้นหาในนั้น
ดังนั้น parser จะตรวจสอบอักขระสองสามตัวถัดไปกับรูปแบบที่เสนอ (werty) หากพบแล้วข้อความนั้นเป็นเท็จซึ่งหมายความว่าอักขระ q จะถูก "ละเว้น" นั่นคือจะไม่ตรงกับรูปแบบ หากไม่พบ werty แสดงว่าข้อความนั้นเป็นจริง และทุกอย่างจะเป็นไปตามลำดับด้วย q จากนั้นการค้นหาอักขระอื่นๆ ที่ไม่ใช่ช่องว่าง ([^\s]*) จะดำเนินต่อไป
ปริมาณตัวระบุปริมาณช่วยให้คุณสามารถกำหนดส่วนของรูปแบบที่ต้องทำซ้ำหลายครั้งติดต่อกัน ตัวอย่างเช่น หากคุณต้องการทราบว่าเอกสารมีสตริงตัวอักษร "a" จำนวน 10 ถึง 20 ตัว (รวม) หรือไม่ คุณสามารถใช้รูปแบบนี้:
เอ(10,20)
ตามค่าเริ่มต้น ตัวระบุปริมาณจะ "โลภ" ดังนั้น ปริมาณ + ซึ่งหมายถึง "หนึ่งครั้งหรือมากกว่า" จะสอดคล้องกับค่าสูงสุดที่เป็นไปได้ บางครั้งสิ่งนี้ทำให้เกิดปัญหา ในกรณีนี้ คุณสามารถบอกปริมาณให้หยุดโลภได้ (กลายเป็น "ขี้เกียจ") โดยใช้ตัวแก้ไขพิเศษ ดูรหัสนี้:
".*"รูปแบบนี้ตรงกับข้อความที่อยู่ในเครื่องหมายคำพูดคู่ อย่างไรก็ตาม บรรทัดแหล่งที่มาของคุณอาจเป็นดังนี้:
สวัสดีชาวโลก
เทมเพลตด้านบนจะค้นหาสตริงย่อยต่อไปนี้ในบรรทัดนี้:
"helloworld.htm" title="Hello World" !}
เขากลายเป็นคนโลภเกินไป โดยคว้าข้อความชิ้นใหญ่ที่สุดที่เขาสามารถทำได้
".*?"รูปแบบนี้ยังจับคู่อักขระใดๆ ที่อยู่ในเครื่องหมายคำพูดคู่ด้วย แต่เวอร์ชันขี้เกียจ (สังเกตเห็นตัวแก้ไขหรือไม่) จะมองหาเหตุการณ์ที่เล็กที่สุดเท่าที่จะเป็นไปได้ และจะค้นหาสตริงย่อยที่มีเครื่องหมายคำพูดคู่แต่ละรายการทีละรายการ:
"helloworld.htm" "สวัสดีชาวโลก"
การหลบหนีในการแสดงออกปกตินิพจน์ทั่วไปใช้อักขระบางตัวเพื่อแสดงส่วนต่างๆ ของรูปแบบ อย่างไรก็ตาม ปัญหาจะเกิดขึ้นหากคุณต้องการค้นหาอักขระตัวใดตัวหนึ่งเหล่านี้ในสตริง เช่นเดียวกับอักขระทั่วไป ตัวอย่างเช่น จุด ในนิพจน์ทั่วไปหมายถึง "อักขระใดๆ ที่ไม่ใช่ตัวแบ่งบรรทัด" หากคุณต้องการค้นหาจุดในสตริง คุณไม่สามารถใช้ " เท่านั้น ” เป็นเทมเพลต - สิ่งนี้จะนำไปสู่การค้นหาเกือบทุกอย่าง ดังนั้น คุณต้องบอก parser ว่าจุดนี้ควรถือเป็นจุดปกติ ไม่ใช่ "อักขระใดๆ" ทำได้โดยใช้ป้ายทางหนี
อักขระหลีกที่อยู่นำหน้าอักขระ เช่น จุด ทำให้ parser ละเว้นฟังก์ชันและถือเป็นอักขระปกติ มีอักขระหลายตัวที่ต้องมีการ Escape ดังกล่าวในเทมเพลตและภาษาส่วนใหญ่ คุณสามารถดูได้ที่มุมขวาล่างของแผ่นโกง (“Meta Symbols”)
รูปแบบการหาจุดคือ:
\.อักขระพิเศษอื่นๆ ในนิพจน์ทั่วไปตรงกับองค์ประกอบที่ผิดปกติในข้อความ ตัวอย่างเช่น การขึ้นบรรทัดใหม่และแท็บสามารถพิมพ์บนแป้นพิมพ์ได้ แต่อาจทำให้ภาษาการเขียนโปรแกรมสับสนได้ อักขระหลีกถูกใช้ที่นี่เพื่อบอกให้ parser ถือว่าอักขระถัดไปเป็นแบบพิเศษแทนที่จะเป็น จดหมายปกติหรือหมายเลข
อักขระหลีกพิเศษในนิพจน์ทั่วไป การทดแทนสตริงการทดแทนสตริงได้รับการอธิบายโดยละเอียดในย่อหน้าถัดไป “กลุ่มและช่วง” แต่ควรกล่าวถึงการมีอยู่ของกลุ่ม “พาสซีฟ” ที่นี่ กลุ่มเหล่านี้คือกลุ่มที่ถูกละเลยในระหว่างการทดแทน ซึ่งมีประโยชน์มากหากคุณต้องการใช้เงื่อนไข "หรือ" ในรูปแบบ แต่ไม่ต้องการให้กลุ่มนั้นมีส่วนร่วมในการทดแทน
กลุ่มและช่วงกลุ่มและช่วงมีประโยชน์มาก มันอาจจะง่ายกว่าที่จะเริ่มต้นด้วยช่วง ช่วยให้คุณสามารถระบุชุดอักขระที่เหมาะสมได้ ตัวอย่างเช่น หากต้องการตรวจสอบว่าสตริงมีเลขฐานสิบหก (0 ถึง 9 และ A ถึง F) หรือไม่ คุณจะต้องใช้ช่วงต่อไปนี้:
หากต้องการตรวจสอบสิ่งที่ตรงกันข้าม ให้ใช้ช่วงค่าลบ ซึ่งในกรณีของเราเหมาะกับอักขระใดๆ ยกเว้นตัวเลขตั้งแต่ 0 ถึง 9 และตัวอักษรตั้งแต่ A ถึง F:
[^เอ-ฟ้า-f0-9]
กลุ่มมักใช้เมื่อจำเป็นต้องมีเงื่อนไข "หรือ" ในรูปแบบ เมื่อคุณต้องการอ้างอิงถึงส่วนหนึ่งของเทมเพลตจากส่วนอื่น และเมื่อทำการแทนที่สตริงด้วย
การใช้ "or" นั้นง่ายมาก: รูปแบบต่อไปนี้จะค้นหา "ab" หรือ "bc":
หากในนิพจน์ทั่วไปจำเป็นต้องอ้างอิงถึงกลุ่มก่อนหน้าใดๆ คุณควรใช้ \n โดยที่แทนที่จะใช้ n แทนตัวเลข กลุ่มที่ต้องการ- คุณอาจต้องใช้รูปแบบที่ตรงกับตัวอักษร "aaa" หรือ "bbb" ตามด้วยตัวเลขและตัวอักษรสามตัวที่เหมือนกัน รูปแบบนี้ถูกนำมาใช้โดยใช้กลุ่ม:
(aaa|bbb)+\1
ส่วนแรกของรูปแบบจะมองหา "aaa" หรือ "bbb" ซึ่งเป็นการรวมตัวอักษรที่พบในกลุ่ม ตามด้วยการค้นหาตัวเลขอย่างน้อยหนึ่งหลัก (+) และสุดท้ายคือ \1 ส่วนสุดท้ายของรูปแบบอ้างอิงถึงกลุ่มแรกและมองหาสิ่งเดียวกัน ค้นหารายการที่ตรงกันกับข้อความที่พบแล้วในส่วนแรกของรูปแบบ ไม่ใช่รายการที่ตรงกัน ดังนั้น "aaa123bbb" จะไม่เป็นไปตามรูปแบบข้างต้น เนื่องจาก \1 จะมองหา "aaa" หลังตัวเลข
หนึ่งในที่สุด เครื่องมือที่มีประโยชน์ในนิพจน์ทั่วไปคือการทดแทนสตริง เมื่อแทนที่ข้อความ คุณสามารถอ้างอิงกลุ่มที่พบโดยใช้ $n สมมติว่าคุณต้องการเน้นคำว่า "ปรารถนา" ทั้งหมดด้วยตัวหนา ในการดำเนินการนี้ คุณควรใช้ฟังก์ชันแทนที่นิพจน์ทั่วไป ซึ่งอาจมีลักษณะดังนี้:
แทนที่(รูปแบบ การแทนที่ หัวเรื่อง)
พารามิเตอร์แรกจะเป็นดังนี้ (คุณอาจต้องใช้อักขระพิเศษสองสามตัวสำหรับฟังก์ชันเฉพาะนี้):
([^A-Za-z0-9])(ปรารถนา)([^A-Za-z0-9])
โดยจะค้นหาคำว่า "ความปรารถนา" ที่เกิดขึ้นพร้อมกับอักขระก่อนหน้าและถัดไป ตราบใดที่ไม่ใช่ตัวอักษรหรือตัวเลข จากนั้นการทดแทนของคุณอาจเป็นดังนี้:
$1$2$3
มันจะแทนที่สตริงทั้งหมดที่พบโดยใช้รูปแบบ เราเริ่มแทนที่ด้วยอักขระตัวแรกที่พบ (ซึ่งไม่ใช่ตัวอักษรหรือตัวเลข) โดยทำเครื่องหมายไว้ $1 หากไม่มีสิ่งนี้ เราก็จะลบอักขระนี้ออกจากข้อความ เช่นเดียวกับการสิ้นสุดการเปลี่ยนตัว ($3) ตรงกลางเราเพิ่ม แท็ก HTMLเป็นตัวหนา (แน่นอน คุณสามารถใช้ CSS หรือแทนก็ได้) โดยเน้นกลุ่มที่สองที่พบจากเทมเพลต ($2)
นิพจน์ทั่วไป
นิพจน์ทั่วไปคือวัตถุที่อธิบายรูปแบบอักขระ คลาส RegExp ใน JavaScript แสดงถึงนิพจน์ทั่วไป และออบเจ็กต์คลาส String และ RegExp จะกำหนดวิธีการที่ใช้นิพจน์ทั่วไปเพื่อทำการจับคู่รูปแบบและการค้นหาข้อความและการดำเนินการแทนที่ ไวยากรณ์นิพจน์ทั่วไปใน จาวาสคริปต์มีชุดย่อยที่ค่อนข้างสมบูรณ์ของไวยากรณ์นิพจน์ทั่วไปที่ใช้ใน Perl 5 ดังนั้นหากคุณมีประสบการณ์กับภาษา Perl คุณสามารถอธิบายรูปแบบในโปรแกรม JavaScript ได้อย่างง่ายดาย
คุณลักษณะของนิพจน์ทั่วไป Perl ที่ไม่ได้รับการสนับสนุนใน ECMAScript ได้แก่ แฟล็ก s (โหมดบรรทัดเดียว) และ x (ไวยากรณ์แบบขยาย) ลำดับหลีก \a, \e, \l, \u, \L, \U, \E, \Q, \A, \Z, \z และ \G และโครงสร้างเพิ่มเติมอื่นๆ ที่ขึ้นต้นด้วย (?.
การกำหนดนิพจน์ปกติใน จาวาสคริปต์ปกตินิพจน์จะแสดงด้วยวัตถุ RegExp ออบเจ็กต์ RegExp สามารถสร้างได้โดยใช้ตัวสร้าง RegExp() แต่บ่อยครั้งที่วัตถุนั้นถูกสร้างขึ้นโดยใช้ ไวยากรณ์พิเศษตัวอักษร เช่นเดียวกับการระบุตัวอักษรสตริงเป็นอักขระที่ล้อมรอบด้วยเครื่องหมายคำพูด ตัวอักษรนิพจน์ทั่วไปจะถูกระบุเป็นอักขระที่ล้อมรอบด้วยอักขระสแลชคู่ (/) ดังนั้นโค้ด JavaScript ของคุณอาจมีบรรทัดดังนี้:
รูปแบบวาร์ = /s$/;
เส้นนี้สร้าง วัตถุใหม่ RegExp และกำหนดให้กับตัวแปรรูปแบบ วัตถุชิ้นนี้ RegExp ค้นหาสตริงที่ลงท้ายด้วย "s" นิพจน์ทั่วไปเดียวกันสามารถกำหนดได้โดยใช้ตัวสร้าง RegExp():
รูปแบบ Var = RegExp ใหม่("s$");
ข้อกำหนดรูปแบบนิพจน์ทั่วไปประกอบด้วยลำดับของอักขระ อักขระส่วนใหญ่ รวมทั้งอักขระตัวอักษรและตัวเลขทั้งหมด อธิบายอักขระที่ต้องมีอยู่อย่างแท้จริง นั่นคือนิพจน์ทั่วไป /java/ จะจับคู่ทุกบรรทัดที่มีสตริงย่อย “java”
อักขระอื่นๆ ในนิพจน์ทั่วไปไม่ได้มีวัตถุประสงค์เพื่อใช้เพื่อค้นหาสิ่งที่เทียบเท่ากันทุกประการ แต่มีความหมายพิเศษ ตัวอย่างเช่น นิพจน์ทั่วไป /s$/ มีอักขระสองตัว อักขระตัวแรกหมายถึงการค้นหาอักขระตามตัวอักษร ประการที่สอง $ คืออักขระเมตาพิเศษที่เป็นจุดสิ้นสุดของบรรทัด ดังนั้นนิพจน์ทั่วไปนี้จะจับคู่สตริงใดๆ ที่ลงท้ายด้วยอักขระ s
ส่วนต่อไปนี้จะอธิบายอักขระและอักขระเมตาต่างๆ ที่ใช้ในนิพจน์ทั่วไปใน JavaScript
อักขระตามตัวอักษรตามที่ระบุไว้ก่อนหน้านี้ อักขระตัวอักษรและตัวเลขทั้งหมดในนิพจน์ทั่วไปจะตรงกัน ไวยากรณ์นิพจน์ทั่วไปใน JavaScript ยังสนับสนุนความสามารถในการระบุอักขระที่ไม่ใช่ตัวอักษรบางตัวโดยใช้ลำดับการหลีกเลี่ยงที่เริ่มต้นด้วยอักขระแบ็กสแลช (\) ตัวอย่างเช่น ลำดับ \n ตรงกับอักขระขึ้นบรรทัดใหม่ สัญลักษณ์เหล่านี้แสดงอยู่ในตารางด้านล่าง:
เครื่องหมายวรรคตอนบางอันมีความหมายพิเศษในนิพจน์ทั่วไป:
^ $ . * + ? = ! : | \ / () { } -
ความหมายของสัญลักษณ์เหล่านี้อธิบายไว้ในส่วนต่อไปนี้ บางส่วนมีความหมายพิเศษเฉพาะในบริบทของนิพจน์ทั่วไปบางบริบทเท่านั้น ในขณะที่ในบริบทอื่นมีการตีความตามตัวอักษร อย่างไรก็ตาม โดยทั่วไป หากต้องการรวมอักขระใดๆ เหล่านี้ในนิพจน์ทั่วไป คุณต้องนำหน้าด้วยอักขระแบ็กสแลช อักขระอื่นๆ เช่น เครื่องหมายคำพูดและ @ ไม่มีความหมายพิเศษ และเพียงจับคู่ตัวเองในนิพจน์ทั่วไป
หากคุณจำไม่ได้แน่ชัดว่าอักขระตัวใดควรนำหน้าด้วย \ คุณสามารถใส่เครื่องหมายแบ็กสแลชไว้หน้าอักขระใดก็ได้อย่างปลอดภัย อย่างไรก็ตาม โปรดทราบว่าตัวอักษรและตัวเลขจำนวนมากมีความหมายพิเศษเมื่อรวมกับอักขระเครื่องหมายทับ ดังนั้นตัวอักษรและตัวเลขที่คุณกำลังมองหาไม่ควรนำหน้าด้วยอักขระ \ หากต้องการรวมอักขระแบ็กสแลชไว้ในนิพจน์ทั่วไป คุณจะต้องนำหน้าด้วยอักขระแบ็กสแลชอื่นอย่างชัดเจน ตัวอย่างเช่น นิพจน์ทั่วไปต่อไปนี้จะจับคู่สตริงใดๆ ที่มีอักขระแบ็กสแลช: /\\/
คลาสตัวละครอักขระตามตัวอักษรแต่ละตัวสามารถรวมกันเป็นคลาสอักขระได้โดยการใส่ไว้ในวงเล็บเหลี่ยม คลาสอักขระจะจับคู่อักขระใดๆ ที่มีอยู่ในคลาสนั้น ดังนั้น นิพจน์ทั่วไป // จะจับคู่อักขระตัวใดตัวหนึ่ง a, b หรือ c
คลาสอักขระเชิงลบยังสามารถกำหนดเพื่อให้ตรงกับอักขระใดๆ ยกเว้นอักขระที่ระบุในวงเล็บ คลาสอักขระการปฏิเสธถูกระบุโดยอักขระ ^ เป็นอักขระตัวแรกที่อยู่หลังวงเล็บซ้าย นิพจน์ทั่วไป /[^abc]/ จะจับคู่อักขระอื่นที่ไม่ใช่ a, b หรือ c ในคลาสอักขระ ช่วงของอักขระสามารถระบุได้โดยใช้ยัติภังค์ ค้นหาตัวอักษรทั้งหมด ตัวอักษรละตินวี ตัวพิมพ์เล็กเสร็จสิ้นโดยใช้นิพจน์ // และตัวอักษรหรือตัวเลขใดๆ จากชุดอักขระละตินสามารถพบได้โดยใช้นิพจน์ //
คลาสอักขระบางตัวเป็นเรื่องปกติโดยเฉพาะ ดังนั้นไวยากรณ์ของนิพจน์ทั่วไปใน JavaScript จึงรวมอักขระพิเศษและลำดับหลีกเพื่อเป็นตัวแทน ดังนั้น \s จะจับคู่ช่องว่าง แท็บ และอักขระช่องว่าง Unicode และ \S จะจับคู่อักขระช่องว่างที่ไม่ใช่ Unicode
ตารางด้านล่างนี้แสดงรายการอักขระพิเศษเหล่านี้และไวยากรณ์ของคลาสอักขระ (โปรดทราบว่าลำดับการหลีกคลาสอักขระบางตัวตรงกับอักขระ ASCII เท่านั้น และไม่ได้ขยายเพื่อทำงานกับอักขระ Unicode คุณสามารถกำหนดคลาสอักขระ Unicode ของคุณเองได้อย่างชัดเจน เช่น /[\u0400-\u04FF]/ จับคู่อักขระซีริลลิกใดๆ .)
| [...] | อักขระใดๆ ที่แสดงในวงเล็บ |
| [^...] | อักขระใด ๆ ที่ไม่อยู่ในวงเล็บ |
| . | อักขระใดๆ นอกเหนือจากบรรทัดใหม่หรือตัวคั่นบรรทัด Unicode อื่นๆ |
| \w | อักขระข้อความ ASCII ใดๆ เทียบเท่า |
| \ว | อักขระใดๆ ที่ไม่ใช่อักขระข้อความ ASCII เทียบเท่ากับ [^a-zA-Z0-9_] |
| \s | อักขระช่องว่างใดๆ จากชุด Unicode |
| \ส | อักขระที่ไม่ใช่ช่องว่างจากชุด Unicode โปรดทราบว่าอักขระ \w และ \S ไม่ใช่สิ่งเดียวกัน |
| \d | ตัวเลข ASCII ใดๆ เทียบเท่า |
| \D | อักขระใดๆ ที่ไม่ใช่ตัวเลข ASCII เทียบเท่ากับ [^0-9] |
| [\ข] | ตัวอักษรตัวอักษร Backspace |
โปรดทราบว่าลำดับการหลีกอักขระพิเศษของคลาสสามารถอยู่ในวงเล็บเหลี่ยมได้ \s จับคู่อักขระช่องว่างใดๆ และ \d จับคู่ตัวเลขใดๆ ดังนั้น /[\s\d]/ จึงจับคู่อักขระช่องว่างหรือตัวเลขใดๆ
การทำซ้ำเมื่อพิจารณาจากความรู้เกี่ยวกับไวยากรณ์ของนิพจน์ทั่วไปที่ได้รับจนถึงขณะนี้ เราสามารถอธิบายตัวเลขสองหลักเป็น /\d\d/ หรือตัวเลขสี่หลักเป็น /\d\d\d\d/ แต่เราไม่สามารถอธิบายได้ เช่น อธิบายตัวเลขที่ประกอบด้วยตัวเลขจำนวนเท่าใดก็ได้ หรือสตริงที่มีตัวอักษร 3 ตัวตามด้วยตัวเลขเพิ่มเติม รูปแบบที่ซับซ้อนมากขึ้นเหล่านี้ใช้ไวยากรณ์ของนิพจน์ทั่วไปเพื่อระบุจำนวนครั้งของ องค์ประกอบนี้การแสดงออกปกติ
สัญลักษณ์ซ้ำจะเป็นไปตามรูปแบบที่ใช้เสมอ การทำซ้ำบางประเภทใช้ค่อนข้างบ่อยและมีสัญลักษณ์พิเศษเพื่อระบุกรณีเหล่านี้ ตัวอย่างเช่น + จับคู่อินสแตนซ์ของรูปแบบก่อนหน้าตั้งแต่หนึ่งรายการขึ้นไป ตารางต่อไปนี้ให้ข้อมูลสรุปของไวยากรณ์การทำซ้ำ:
บรรทัดต่อไปนี้แสดงตัวอย่างหลายประการ:
รูปแบบวาร์ = /\d(2,4)/; // จับคู่ตัวเลขที่มีรูปแบบสองถึงสี่หลัก = /\w(3)\d?/; // จับคู่อักขระสามคำให้ตรงกันทุกประการและรูปแบบหลักหนึ่งหลักที่เป็นตัวเลือก = /\s+java\s+/; // จับคู่คำว่า "java" ด้วยช่องว่างตั้งแต่หนึ่งช่องขึ้นไป // ก่อนและหลัง pattern = /[^(]*/; // จับคู่อักขระตั้งแต่ศูนย์ขึ้นไปนอกเหนือจากวงเล็บเปิด
ระวังเมื่อใช้อักขระซ้ำ * และ ? พวกเขาสามารถจับคู่การไม่มีรูปแบบที่ระบุไว้ก่อนหน้าและดังนั้นจึงไม่มีอักขระ ตัวอย่างเช่น นิพจน์ทั่วไป /a*/ จะจับคู่สตริง "bbbb" เนื่องจากไม่มีอักขระ a
อักขระการทำซ้ำที่แสดงอยู่ในตารางแสดงถึงจำนวนการทำซ้ำสูงสุดที่เป็นไปได้ ซึ่งจะช่วยให้ส่วนต่อๆ ไปของนิพจน์ทั่วไปสามารถจับคู่ได้ เราว่านี่เป็นการกล่าวซ้ำอย่างละโมบ นอกจากนี้ยังเป็นไปได้ที่จะดำเนินการซ้ำซ้อนในลักษณะที่ไม่โลภ การระบุเครื่องหมายคำถามหลังสัญลักษณ์ซ้ำ (หรือสัญลักษณ์): ??, +?, *? ก็เพียงพอแล้ว หรือแม้แต่ (1.5)?.
ตัวอย่างเช่น นิพจน์ทั่วไป /a+/ จะจับคู่ตัวอักษร a ตั้งแต่หนึ่งตัวขึ้นไป ใช้กับสตริง "aaa" โดยจะจับคู่ตัวอักษรทั้งสามตัว ในทางกลับกัน นิพจน์ /a+?/ จะจับคู่ตัวอักษร a ตั้งแต่หนึ่งอินสแตนซ์ขึ้นไป และเลือกจำนวนอักขระที่น้อยที่สุดที่เป็นไปได้ เมื่อนำไปใช้กับสตริงเดียวกัน รูปแบบนี้จะจับคู่เฉพาะตัวอักษรตัวแรก a เท่านั้น
การกล่าวซ้ำๆ แบบ “ไร้ความโลภ” ไม่ได้ให้ผลลัพธ์ตามที่คาดหวังเสมอไป พิจารณารูปแบบ /a+b/ ซึ่งจับคู่ a อย่างน้อย 1 ตัวที่ตามด้วย b เมื่อนำไปใช้กับสตริง "aaab" จะสอดคล้องกับสตริงทั้งหมด
ตอนนี้เรามาดูเวอร์ชัน "ไม่โลภ" ของ /a+?b/ กัน บางคนอาจคิดว่ามันจะตรงกับ a b ที่นำหน้าด้วย a เพียงตัวเดียว หากใช้กับสตริงเดียวกัน "aaab" จะต้องจับคู่อักขระตัวเดียว a และอักขระตัวสุดท้าย b อย่างไรก็ตาม รูปแบบนี้ตรงกับสตริงทั้งหมดจริงๆ เช่นเดียวกับเวอร์ชันโลภ ความจริงก็คือการค้นหารูปแบบนิพจน์ทั่วไปจะดำเนินการโดยการค้นหาตำแหน่งแรกในสตริง โดยเริ่มจากจุดที่การจับคู่เป็นไปได้ เนื่องจากการจับคู่เป็นไปได้โดยเริ่มจากอักขระตัวแรกของสตริง จึงไม่พิจารณาการจับคู่ที่สั้นกว่าซึ่งเริ่มต้นจากอักขระตัวถัดไปด้วยซ้ำ
ทางเลือก การจัดกลุ่ม และลิงก์ไวยากรณ์นิพจน์ทั่วไปประกอบด้วยอักขระพิเศษสำหรับการกำหนดทางเลือก การจัดกลุ่มนิพจน์ย่อย และการอ้างอิงถึงนิพจน์ย่อยก่อนหน้า สัญลักษณ์ไปป์ | ทำหน้าที่แยกทางเลือก ตัวอย่างเช่น /ab|cd|ef/ จับคู่สตริง "ab" หรือสตริง "cd" หรือสตริง "ef" และรูปแบบ /\d(3)|(4)/ จับคู่ตัวเลขสามหลักตัวใดตัวหนึ่ง หรืออักษรตัวพิมพ์เล็กสี่ตัว
โปรดทราบว่าทางเลือกอื่นจะถูกประมวลผลจากซ้ายไปขวาจนกว่าจะพบรายการที่ตรงกัน หากพบการจับคู่ที่มีทางเลือกทางซ้าย ระบบจะเพิกเฉยต่อการจับคู่ที่ถูกต้อง แม้ว่าจะสามารถบรรลุการจับคู่ที่ "ดีกว่า" ก็ตาม ดังนั้นเมื่อใช้รูปแบบ /a|ab/ กับสตริง "ab" รูปแบบจะจับคู่เฉพาะอักขระตัวแรกเท่านั้น
วงเล็บมีหลายความหมายในนิพจน์ทั่วไป หนึ่งในนั้นคือการจัดกลุ่ม แต่ละองค์ประกอบเป็นนิพจน์ย่อยเดียวเพื่อให้องค์ประกอบเมื่อใช้อักขระพิเศษ |, *, +, ? และอื่น ๆ ก็ถือเป็นส่วนรวม ตัวอย่างเช่น รูปแบบ /java(script)?/ ตรงกับคำว่า "java" ตามด้วยคำเพิ่มเติม "script" และ /(ab|cd)+|ef)/ ตรงกับสตริง "ef" หรือหนึ่งรายการขึ้นไป การซ้ำซ้อนจากสตริง "ab" หรือ "cd"
การใช้วงเล็บในนิพจน์ทั่วไปก็คือการกำหนดรูปแบบย่อยภายในรูปแบบ เมื่อพบการจับคู่นิพจน์ทั่วไปในสตริงเป้าหมาย ส่วนของสตริงเป้าหมายที่ตรงกับรูปแบบย่อยเฉพาะใดๆ ที่อยู่ในวงเล็บสามารถแยกออกมาได้
สมมติว่าคุณต้องการค้นหาตัวอักษรพิมพ์เล็กอย่างน้อยหนึ่งตัวตามด้วยตัวเลขตั้งแต่หนึ่งตัวขึ้นไป เมื่อต้องการทำเช่นนี้ คุณสามารถใช้เทมเพลต /+\d+/ แต่สมมติว่าเราต้องการเฉพาะตัวเลขเมื่อสิ้นสุดการแข่งขันแต่ละนัดเท่านั้น หากเราใส่รูปแบบส่วนนี้ไว้ในวงเล็บ (/+(\d+)/) เราก็สามารถแยกตัวเลขออกจากรายการที่ตรงกันที่เราพบได้ วิธีการดำเนินการนี้จะอธิบายไว้ด้านล่าง
การใช้นิพจน์ย่อยที่อยู่ในวงเล็บที่เกี่ยวข้องคือการอ้างถึงนิพจน์ย่อยจากส่วนก่อนหน้าของนิพจน์ทั่วไปเดียวกัน ซึ่งสามารถทำได้โดยการระบุตัวเลขอย่างน้อยหนึ่งหลักหลังอักขระ \ ตัวเลขอ้างอิงถึงตำแหน่งของนิพจน์ย่อยที่อยู่ในวงเล็บภายในนิพจน์ทั่วไป ตัวอย่างเช่น \1 หมายถึงนิพจน์ย่อยแรก และ \3 หมายถึงนิพจน์ย่อยที่สาม โปรดทราบว่านิพจน์ย่อยสามารถซ้อนกันภายในกันได้ ดังนั้นจึงใช้ตำแหน่งของวงเล็บซ้ายในการนับ ตัวอย่างเช่น ในนิพจน์ทั่วไปต่อไปนี้ การอ้างอิงนิพจน์ย่อยที่ซ้อนกัน (cript) จะมีลักษณะดังนี้ \2:
/(ava(cript)?)\sis\s(สนุก\w*)/
การอ้างอิงถึงนิพจน์ย่อยก่อนหน้าไม่ได้ชี้ไปที่รูปแบบของนิพจน์ย่อยนั้น แต่ชี้ไปที่ข้อความที่พบว่าตรงกับรูปแบบนั้น ดังนั้น การอ้างอิงสามารถใช้เพื่อกำหนดข้อจำกัดที่เลือกส่วนของสตริงที่มีอักขระที่เหมือนกันทุกประการ ตัวอย่างเช่น นิพจน์ทั่วไปต่อไปนี้จะจับคู่อักขระตั้งแต่ 0 ตัวขึ้นไปภายในอักขระเดี่ยวหรือ เครื่องหมายคำพูดคู่- อย่างไรก็ตาม ไม่จำเป็นต้องให้ราคาเปิดและปิดต้องตรงกัน (นั่นคือ ทั้งสองราคาเป็นแบบเดี่ยวหรือคู่):
/[""][^""]*[""]/
เราสามารถกำหนดให้เครื่องหมายคำพูดตรงกันโดยใช้การอ้างอิงดังนี้:
ที่นี่ \1 ตรงกับนิพจน์ย่อยแรก ในตัวอย่างนี้ ลิงก์กำหนดข้อจำกัดที่ต้องใช้เครื่องหมายคำพูดปิดเพื่อให้ตรงกับเครื่องหมายคำพูดเปิด นิพจน์ทั่วไปนี้ไม่อนุญาตให้ใช้เครื่องหมายคำพูดเดี่ยวภายในเครื่องหมายคำพูดคู่ และในทางกลับกัน
นอกจากนี้ยังสามารถจัดกลุ่มองค์ประกอบในนิพจน์ทั่วไปได้โดยไม่ต้องสร้างการอ้างอิงที่เป็นตัวเลขไปยังองค์ประกอบเหล่านั้น แทนที่จะจัดกลุ่มองค์ประกอบระหว่าง ( และ ) ให้เริ่มกลุ่มด้วยสัญลักษณ์ (?: และปิดท้ายด้วยสัญลักษณ์) พิจารณาตัวอย่างรูปแบบต่อไปนี้:
/(ava(?:cript)?)\sis\s(สนุก\w*)/
ในที่นี้ นิพจน์ย่อย (?:cript) จำเป็นสำหรับการจัดกลุ่มเท่านั้น เพื่อให้สามารถนำไปใช้กับกลุ่มอักขระซ้ำได้ วงเล็บที่ถูกแก้ไขเหล่านี้ไม่ได้สร้างลิงก์ ดังนั้นในนิพจน์ทั่วไปนี้ \2 หมายถึงข้อความที่ตรงกับรูปแบบ (fun\w*)
ตารางต่อไปนี้แสดงรายการตัวเลือก การจัดกลุ่ม และตัวดำเนินการอ้างอิงในนิพจน์ทั่วไป:
| | | ทางเลือก. จับคู่นิพจน์ย่อยทางด้านซ้ายหรือนิพจน์ย่อยทางด้านขวา |
| (...) | การจัดกลุ่ม จัดกลุ่มองค์ประกอบให้เป็นหน่วยเดียวที่สามารถใช้กับอักขระ *, +, ?, | ฯลฯ ยังจำอักขระที่ตรงกับกลุ่มนี้เพื่อใช้ในการอ้างอิงครั้งต่อไป |
| (?:...) | การจัดกลุ่มเท่านั้น จัดกลุ่มองค์ประกอบให้เป็นหน่วยเดียว แต่จำอักขระที่ตรงกับกลุ่มนี้ไม่ได้ |
| \ตัวเลข | จับคู่อักขระเดียวกันกับที่พบในเมื่อจับคู่หมายเลขหมายเลขกลุ่ม กลุ่มคือนิพจน์ย่อยภายในวงเล็บ (อาจซ้อนกัน) กำหนดหมายเลขกลุ่มโดยการนับวงเล็บซ้ายจากซ้ายไปขวา กลุ่มที่สร้างโดยใช้สัญลักษณ์ (?:) จะไม่ถูกใส่หมายเลข |
ตามที่อธิบายไว้ก่อนหน้านี้ องค์ประกอบต่างๆ ของนิพจน์ทั่วไปจะจับคู่อักขระตัวเดียวในสตริง ตัวอย่างเช่น \s จับคู่อักขระช่องว่างตัวเดียว องค์ประกอบนิพจน์ทั่วไปอื่นๆ จะจับคู่ตำแหน่งระหว่างอักขระมากกว่าตัวอักขระเอง ตัวอย่างเช่น \b จะจับคู่ขอบเขตของคำ เช่น ขอบเขตระหว่าง \w (อักขระข้อความ ASCII) และ \W (อักขระที่ไม่ใช่ข้อความ) หรือขอบเขตระหว่างอักขระข้อความ ASCII กับจุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัด
องค์ประกอบเช่น \b ไม่ได้ระบุอักขระใดๆ ที่ต้องปรากฏในสตริงที่ตรงกัน แต่จะระบุตำแหน่งที่ถูกต้องสำหรับการจับคู่ องค์ประกอบเหล่านี้บางครั้งเรียกว่าองค์ประกอบสมอนิพจน์ทั่วไปเนื่องจากจะยึดรูปแบบไปยังตำแหน่งเฉพาะในสตริง องค์ประกอบจุดยึดที่ใช้กันมากที่สุดคือ ^ และ $ ซึ่งเชื่อมโยงรูปแบบไปยังจุดเริ่มต้นและจุดสิ้นสุดของบรรทัดตามลำดับ
ตัวอย่างเช่น คำว่า "JavaScript" ในบรรทัดของตัวเองสามารถพบได้โดยใช้นิพจน์ทั่วไป /^JavaScript$/ หากต้องการค้นหาคำเดียวว่า "Java" (แทนที่จะเป็นคำนำหน้าเช่น "JavaScript") คุณสามารถลองใช้รูปแบบ /\sJava\s/ ซึ่งต้องเว้นวรรคก่อนและหลังคำนั้น
แต่วิธีแก้ปัญหาดังกล่าวทำให้เกิดปัญหาสองประการ ขั้นแรกจะค้นหาคำว่า "Java" เท่านั้นหากมีช่องว่างทั้งสองด้านล้อมรอบ และจะไม่สามารถค้นหาได้ที่จุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัด ประการที่สอง เมื่อรูปแบบนี้ตรงกัน สตริงที่ส่งคืนจะมีช่องว่างนำหน้าและต่อท้าย ซึ่งไม่ใช่สิ่งที่เราต้องการอย่างแน่นอน ดังนั้นแทนที่จะใช้รูปแบบที่ตรงกับอักขระช่องว่าง \s เราจะใช้รูปแบบ (หรือจุดยึด) ที่ตรงกับขอบเขตคำ \b ผลลัพธ์จะเป็นนิพจน์ต่อไปนี้: /\bJava\b/
องค์ประกอบจุดยึด \B จับคู่ตำแหน่งที่ไม่ใช่ขอบเขตคำ นั่นคือรูปแบบ /\Bcript/ จะตรงกับคำว่า “JavaScript” และ “postscript” และจะไม่ตรงกับคำว่า “script” หรือ “Scripting”
นิพจน์ทั่วไปตามอำเภอใจยังสามารถใช้เป็นเงื่อนไขจุดยึดได้อีกด้วย หากคุณวางนิพจน์ระหว่างอักขระ (?= และ) จะกลายเป็นการทดสอบการจับคู่แบบส่งต่อกับอักขระที่ตามมา โดยกำหนดให้อักขระเหล่านั้นต้องตรงกับรูปแบบที่ระบุ แต่ไม่รวมในสตริงการจับคู่
ตัวอย่างเช่น หากต้องการจับคู่ชื่อของภาษาโปรแกรมทั่วไปที่ตามด้วยโคลอน คุณสามารถใช้นิพจน์ /ava(cript)?(?=\:)/ รูปแบบนี้ตรงกับคำว่า "JavaScript" ในสตริง "JavaScript: The Definitive Guide" แต่จะไม่ตรงกับคำว่า "Java" ในสตริง "Java in a Nutshell" เนื่องจากไม่ได้ตามด้วยโคลอน
หากคุณป้อนเงื่อนไข (?!) นี่จะเป็นการตรวจสอบการส่งต่อเชิงลบสำหรับอักขระที่ตามมา โดยกำหนดให้อักขระต่อไปนี้ไม่ตรงกับรูปแบบที่ระบุ ตัวอย่างเช่น รูปแบบ /Java(?!Script)(\w* )/ จับคู่สตริงย่อย “Java” ตามด้วยอักษรตัวใหญ่และอักขระข้อความ ASCII จำนวนเท่าใดก็ได้ โดยมีเงื่อนไขว่าสตริงย่อย "Java" ไม่ได้ตามด้วยสตริงย่อย "Script" ซึ่งจะจับคู่สตริง "JavaBeans" แต่จะจับคู่ ไม่ตรงกับสตริง "Javanese" จะจับคู่สตริง "JavaScrip" " แต่จะไม่ตรงกับสตริง "JavaScript" หรือ "JavaScripter"
ตารางด้านล่างแสดงรายการอักขระจุดยึดนิพจน์ทั่วไป:
| ^ | จับคู่จุดเริ่มต้นของนิพจน์สตริงหรือจุดเริ่มต้นของบรรทัดในการค้นหาหลายบรรทัด |
| $ | จับคู่จุดสิ้นสุดของนิพจน์สตริงหรือจุดสิ้นสุดของบรรทัดในการค้นหาหลายบรรทัด |
| \ข | จับคู่ขอบเขตคำ เช่น จับคู่ตำแหน่งระหว่างอักขระ \w และอักขระ \W หรือระหว่างอักขระ \w กับจุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัด (โปรดทราบว่า [\b] ตรงกับอักขระ Backspace) |
| \บี | จับคู่ตำแหน่งที่ไม่ใช่ขอบเขตคำ |
| (?=พี) | การตรวจสอบ lookahead เชิงบวกสำหรับอักขระที่ตามมา ต้องใช้อักขระที่ตามมาเพื่อให้ตรงกับรูปแบบ p แต่ไม่รวมอักขระเหล่านั้นในสตริงที่ตรงกัน |
| (?!พี) | การตรวจสอบการส่งต่อเชิงลบสำหรับอักขระที่ตามมา กำหนดให้อักขระต่อไปนี้ไม่ตรงกับรูปแบบ p |
และองค์ประกอบสุดท้ายของไวยากรณ์นิพจน์ทั่วไป ธงนิพจน์ทั่วไประบุกฎการจับคู่รูปแบบระดับสูง ต่างจากไวยากรณ์นิพจน์ทั่วไปอื่นๆ ตรงที่แฟล็กไม่ได้ระบุระหว่างอักขระสแลช แต่อยู่หลังอักขระตัวที่สอง JavaScript รองรับสามแฟล็ก
ตั้งค่าสถานะฉันระบุว่าการจับคู่รูปแบบควรคำนึงถึงขนาดตัวพิมพ์ และ ธงก- การค้นหาควรเป็นสากล เช่น จะต้องพบรายการที่ตรงกันทั้งหมดในสตริง ธงมทำการค้นหารูปแบบในโหมดหลายบรรทัด หากนิพจน์สตริงที่กำลังค้นหามีการขึ้นบรรทัดใหม่ ในโหมดนี้อักขระจุดยึด ^ และ $ นอกเหนือจากการจับคู่จุดเริ่มต้นและจุดสิ้นสุดของนิพจน์สตริงทั้งหมดแล้ว ยังจับคู่จุดเริ่มต้นและจุดสิ้นสุดของแต่ละอักขระด้วย สตริงข้อความ- ตัวอย่างเช่น รูปแบบ /java$/im ตรงกับทั้ง “java” และ “Java\nis fun”
ธงเหล่านี้สามารถนำมารวมกันในรูปแบบใดก็ได้ ตัวอย่างเช่น หากต้องการค้นหาคำว่า "java" (หรือ "Java", "JAVA" ฯลฯ) ที่เกิดขึ้นครั้งแรกในลักษณะที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ คุณสามารถใช้นิพจน์ทั่วไปที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ /\bjava\b/ ฉัน. และหากต้องการค้นหาคำนี้ที่เกิดขึ้นทั้งหมดในสตริง คุณสามารถเพิ่มแฟล็ก g: /\bjava\b/gi
วิธีการ สตริงคลาสเพื่อค้นหาตามรูปแบบเมื่อถึงจุดนี้ เราได้พูดคุยถึงไวยากรณ์ของนิพจน์ทั่วไปที่เราสร้างขึ้น แต่เราไม่ได้พิจารณาว่านิพจน์ทั่วไปเหล่านั้นสามารถนำไปใช้จริงในสคริปต์ JavaScript ได้อย่างไร ใน ส่วนนี้เราจะหารือถึงวิธีการของวัตถุ String ที่ใช้นิพจน์ทั่วไปสำหรับการจับคู่รูปแบบและการค้นหาด้วยการแทนที่ จากนั้นเราจะสนทนาต่อเกี่ยวกับการจับคู่รูปแบบกับนิพจน์ทั่วไปโดยดูที่ออบเจ็กต์ RegExp รวมถึงวิธีการและคุณสมบัติของมัน
สตริงรองรับสี่วิธีโดยใช้นิพจน์ทั่วไป วิธีที่ง่ายที่สุดคือเมธอด search() ใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์และส่งกลับตำแหน่งของอักขระตัวแรกของสตริงย่อยที่ตรงกัน หรือส่งกลับ -1 หากไม่พบรายการที่ตรงกัน ตัวอย่างเช่น การโทรต่อไปนี้จะส่งคืน 4:
ผลลัพธ์ Var = "JavaScript".search(/script/i); // 4
หากอาร์กิวเมนต์ของเมธอด search() ไม่ใช่นิพจน์ทั่วไป ขั้นแรกจะถูกแปลงโดยส่งผ่านไปยังตัวสร้าง RegExp เมธอด search() ไม่รองรับการค้นหาทั่วโลกและละเว้นค่าสถานะ g ในอาร์กิวเมนต์
วิธีการแทนที่() ทำการค้นหาและดำเนินการแทนที่ ใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์แรกและสตริงการแทนที่เป็นอาร์กิวเมนต์ที่สอง วิธีการค้นหาบรรทัดที่ถูกเรียกให้ตรงกับรูปแบบที่ระบุ
หากนิพจน์ทั่วไปมีแฟล็ก g วิธีการแทนที่ () จะแทนที่รายการที่ตรงกันทั้งหมดที่พบด้วยสตริงการแทนที่ มิฉะนั้นจะแทนที่เฉพาะรายการที่ตรงกันแรกที่พบ ถ้าอาร์กิวเมนต์แรกของเมธอดแทนที่() เป็นสตริงแทนที่จะเป็นนิพจน์ทั่วไป เมธอดนั้นจะทำการค้นหาสตริงตามตัวอักษร แทนที่จะแปลงเป็นนิพจน์ทั่วไปโดยใช้คอนสตรัคเตอร์ RegExp() เช่นเดียวกับเมธอด search()
ตัวอย่างเช่น เราสามารถใช้เมธอดการแทนที่() สำหรับการวางตำแหน่งที่สม่ำเสมอ ตัวพิมพ์ใหญ่ในคำว่า "JavaScript" สำหรับข้อความทั้งบรรทัด:
// โดยไม่คำนึงถึงกรณีของอักขระ เราจะแทนที่ด้วยคำในกรณีที่จำเป็น var result = "javascript".replace(/JavaScript/ig, "JavaScript");
วิธีการแทนที่ () มีมากกว่านั้น เครื่องมืออันทรงพลังกว่าตัวอย่างนี้จะแนะนำ ฉันขอเตือนคุณว่านิพจน์ย่อยในวงเล็บภายในนิพจน์ทั่วไปจะมีหมายเลขจากซ้ายไปขวา และนิพจน์ทั่วไปจะจดจำข้อความที่สอดคล้องกับนิพจน์ย่อยแต่ละรายการ หากสตริงการแทนที่มีเครื่องหมาย $ ตามด้วยตัวเลข วิธีการแทนที่ () จะแทนที่อักขระสองตัวนั้นด้วยข้อความที่ตรงกับนิพจน์ย่อยที่ระบุ นี้เป็นอย่างมาก โอกาสที่เป็นประโยชน์- ตัวอย่างเช่น เราสามารถใช้มันเพื่อแทนที่เครื่องหมายคำพูดแบบตรงในสตริงด้วยเครื่องหมายคำพูดแบบพิมพ์ ซึ่งจำลองด้วยอักขระ ASCII:
// เครื่องหมายคำพูดคือเครื่องหมายคำพูดที่ตามด้วยอักขระจำนวนเท่าใดก็ได้ // นอกเหนือจากเครื่องหมายคำพูด (ซึ่งเราจำได้) ตามด้วยเครื่องหมายคำพูดอื่น // var quote = /"([^"]*)"/g; // แทนที่ เครื่องหมายคำพูดตรงที่มีตัวพิมพ์และปล่อยให้ "$1" ไม่เปลี่ยนแปลง // เนื้อหาของเครื่องหมายคำพูดที่เก็บไว้ใน $1 var text = ""JavaScript" เป็นภาษาการเขียนโปรแกรมที่ตีความ"; var result = text.replace(quote, ""$1"" ); // "JavaScript" เป็นภาษาโปรแกรมที่ตีความ
สิ่งสำคัญที่ควรทราบคืออาร์กิวเมนต์ที่สองที่จะแทนที่ () อาจเป็นฟังก์ชันที่คำนวณสตริงการแทนที่แบบไดนามิก
เมธอด match() เป็นเมธอดคลาส String ที่ใช้นิพจน์ทั่วไปมากที่สุด ใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์เดียว (หรือแปลงอาร์กิวเมนต์เป็นนิพจน์ทั่วไปโดยส่งไปยังตัวสร้าง RegExp()) และส่งกลับอาร์เรย์ที่มีผลการค้นหา หากตั้งค่าสถานะ g ในนิพจน์ทั่วไป วิธีการจะส่งคืนอาร์เรย์ของรายการที่ตรงกันทั้งหมดที่มีอยู่ในสตริง ตัวอย่างเช่น:
// จะคืนค่า ["1", "2", "3"] var result = "1 บวก 2 เท่ากับ 3".match(/\d+/g);
หากนิพจน์ทั่วไปไม่มีแฟล็ก g เมธอด match() จะไม่ทำการค้นหาทั่วโลก มันแค่มองหานัดแรก อย่างไรก็ตาม match() จะส่งคืนอาร์เรย์แม้ว่าเมธอดดังกล่าวจะไม่ทำการค้นหาทั่วโลกก็ตาม ในกรณีนี้ องค์ประกอบแรกของอาร์เรย์คือสตริงย่อยที่พบ และองค์ประกอบที่เหลือทั้งหมดเป็นนิพจน์ย่อยของนิพจน์ทั่วไป ดังนั้น หาก match() ส่งคืนอาร์เรย์ arr ดังนั้น arr จะมีสตริงทั้งหมดที่พบ arr สตริงย่อยที่สอดคล้องกับนิพจน์ย่อยแรก เป็นต้น เมื่อวาดเส้นคู่ขนานกับเมธอดการแทนที่() เราสามารถพูดได้ว่าเนื้อหาของ $n ถูกป้อนเข้าไปใน arr[n]
ตัวอย่างเช่น ลองดูสิ่งต่อไปนี้ รหัสโปรแกรมซึ่งแยกวิเคราะห์ URL:
วาร์ url = /(\w+):\/\/([\w.]+)\/(\S*)/; var text = "เยี่ยมชมเว็บไซต์ของเรา http://www..php"; ผลลัพธ์ var = text.match(url); if (result != null) ( var fullurl = result; // มี "http://www..php" var protocol = result; // มี "http" var host = result; // มี "www..php" " )
ควรสังเกตว่าสำหรับนิพจน์ทั่วไปที่ไม่มีการตั้งค่าสถานะ g การค้นหาทั่วโลกเมธอด match() จะส่งคืนค่าเดียวกันกับเมธอด exec() ของนิพจน์ทั่วไป: อาร์เรย์ที่ส่งคืนมีคุณสมบัติดัชนีและอินพุต ตามที่อธิบายไว้ในการอภิปรายเกี่ยวกับเมธอด exec() ด้านล่าง
วิธีการสุดท้ายของวัตถุ String ที่ใช้นิพจน์ทั่วไปคือ split() วิธีนี้จะแยกสตริงที่ถูกเรียกออกเป็นอาร์เรย์ของสตริงย่อย โดยใช้อาร์กิวเมนต์เป็นตัวคั่น ตัวอย่างเช่น:
"123,456,789".แยก(","); // กลับ ["123", "456", "789"]
เมธอด split() ยังสามารถใช้นิพจน์ทั่วไปเป็นอาร์กิวเมนต์ได้ ทำให้วิธีนี้มีประสิทธิภาพมากขึ้น ตัวอย่างเช่น คุณสามารถระบุตัวคั่นที่อนุญาต หมายเลขใดก็ได้ช่องว่างทั้งสองด้าน:
"1, 2, 3 , 4 , 5".split(/\s*,\s*/); // กลับ ["1", "2", "3", "4", "5"]
วัตถุ RegExpตามที่กล่าวไว้ นิพจน์ทั่วไปจะแสดงเป็นออบเจ็กต์ RegExp นอกจากตัวสร้าง RegExp() แล้ว ออบเจ็กต์ RegExp ยังสนับสนุนสามวิธีและคุณสมบัติหลายอย่างอีกด้วย
ตัวสร้าง RegExp() รับอาร์กิวเมนต์สตริงหนึ่งหรือสองตัวและสร้างวัตถุ RegExp ใหม่ อาร์กิวเมนต์แรกของ Constructor คือสตริงที่มีเนื้อหาของนิพจน์ทั่วไป เช่น ข้อความที่ต้องปรากฏระหว่างอักขระเครื่องหมายทับในลิเทอรัลของนิพจน์ทั่วไป โปรดทราบว่าตัวอักษรสตริงและนิพจน์ทั่วไปใช้อักขระ \ เพื่อแสดงลำดับการหลีกเลี่ยง ดังนั้นเมื่อส่งนิพจน์ทั่วไปเป็นสตริงลิเทอรัลไปยังตัวสร้าง RegExp() คุณต้องแทนที่อักขระ \ แต่ละตัวด้วยคู่อักขระ \\
อาร์กิวเมนต์ที่สองของ RegExp() อาจหายไป หากระบุ จะกำหนดแฟล็กนิพจน์ทั่วไป จะต้องเป็นหนึ่งในอักขระ g, i, m หรือผสมอักขระเหล่านี้ ตัวอย่างเช่น:
// ค้นหาตัวเลขห้าหลักทั้งหมดในสตริง หมายเหตุ // การใช้สัญลักษณ์ในตัวอย่างนี้ \\ var zipcode = new RegExp("\\d(5)", "g");
ตัวสร้าง RegExp() มีประโยชน์เมื่อมีการสร้างนิพจน์ทั่วไปแบบไดนามิก ดังนั้นจึงไม่สามารถแสดงโดยใช้ไวยากรณ์ลิเทอรัลของนิพจน์ทั่วไปได้ ตัวอย่างเช่น หากต้องการค้นหาสตริงที่ผู้ใช้ป้อน คุณต้องสร้างนิพจน์ทั่วไปที่รันไทม์โดยใช้ RegExp()
คุณสมบัติ RegExpแต่ละวัตถุ RegExp มีคุณสมบัติห้าประการ คุณสมบัติแหล่งที่มาเป็นสตริงแบบอ่านอย่างเดียวที่มีข้อความของนิพจน์ทั่วไป คุณสมบัติโกลบอลเป็นค่าบูลีนแบบอ่านอย่างเดียวที่กำหนดว่าแฟล็ก g ปรากฏในนิพจน์ทั่วไปหรือไม่ คุณสมบัติ LearnCase เป็นค่าบูลีนแบบอ่านอย่างเดียวที่กำหนดว่าแฟล็ก i ปรากฏในนิพจน์ทั่วไปหรือไม่ คุณสมบัติหลายบรรทัดเป็นค่าบูลีนแบบอ่านอย่างเดียวที่กำหนดว่าแฟล็ก m ปรากฏในนิพจน์ทั่วไปหรือไม่ และคุณสมบัติสุดท้ายคือ LastIndex เป็นจำนวนเต็มที่สามารถอ่านและเขียนได้ สำหรับรูปแบบที่มีแฟล็ก g คุณสมบัตินี้จะมีหมายเลขตำแหน่งในบรรทัดที่ควรเริ่มต้นการค้นหาครั้งถัดไป ตามที่อธิบายไว้ด้านล่าง มันถูกใช้งานโดยเมธอด exec() และ test()
วิธีการ RegExpวัตถุ RegExp กำหนดสองวิธีที่ทำการจับคู่รูปแบบ พวกเขาทำงานคล้ายกับเมธอดคลาส String ที่อธิบายไว้ข้างต้น วิธีการหลักของคลาส RegExp ที่ใช้สำหรับการจับคู่รูปแบบคือ exec() คล้ายกับเมธอด String class match() ที่กล่าวถึงข้างต้น ยกเว้นว่าเมธอดคลาส RegExp จะใช้สตริงเป็นอาร์กิวเมนต์ แทนที่จะเป็นเมธอดคลาส String ที่รับอาร์กิวเมนต์ RegExp
exec() วิธีการดำเนินการนิพจน์ทั่วไปสำหรับสตริงที่ระบุเช่น ค้นหาการแข่งขันในสตริง หากไม่พบรายการที่ตรงกัน เมธอดจะส่งกลับค่าว่าง อย่างไรก็ตาม หากพบรายการที่ตรงกัน ระบบจะส่งกลับอาร์เรย์เดียวกันกับอาร์เรย์ที่ส่งคืนโดยเมธอด match() สำหรับการค้นหาโดยไม่มีแฟล็ก g องค์ประกอบศูนย์ของอาร์เรย์ประกอบด้วยสตริงที่ตรงกับนิพจน์ทั่วไปและทั้งหมด องค์ประกอบที่ตามมา- สตริงย่อยที่สอดคล้องกับนิพจน์ย่อยทั้งหมด นอกจากนี้ทรัพย์สิน ดัชนีมีหมายเลขตำแหน่งของอักขระที่ส่วนที่เกี่ยวข้องเริ่มต้นขึ้น และคุณสมบัติ ป้อนข้อมูลหมายถึงบรรทัดที่ถูกค้นหา
ซึ่งแตกต่างจาก match() เมธอด exec() ส่งคืนอาร์เรย์ที่มีโครงสร้างไม่ขึ้นอยู่กับการมีอยู่ของธง g ในนิพจน์ทั่วไป ฉันขอเตือนคุณว่าเมื่อส่งนิพจน์ทั่วไปทั่วไป เมธอด match() จะส่งคืนอาร์เรย์ของรายการที่ตรงกันที่พบ และ exec() ส่งคืนหนึ่งรายการที่ตรงกันเสมอ แต่ให้ข้อมูลเกี่ยวกับมัน ข้อมูลครบถ้วน- เมื่อเรียก exec() บนนิพจน์ทั่วไปที่มีแฟล็ก g เมธอดจะตั้งค่าคุณสมบัติ LastIndex ของออบเจ็กต์นิพจน์ทั่วไปเป็นหมายเลขตำแหน่งของอักขระทันทีต่อจากสตริงย่อยที่พบ
เมื่อ exec() ถูกเรียกเป็นครั้งที่สองในนิพจน์ทั่วไปเดียวกัน จะเริ่มต้นการค้นหาที่อักขระซึ่งมีการระบุตำแหน่งในคุณสมบัติ LastIndex หาก exec() ไม่พบรายการที่ตรงกัน คุณสมบัติ LastIndex จะถูกตั้งค่าเป็น 0 (คุณยังสามารถตั้งค่า LastIndex ให้เป็นศูนย์ได้ตลอดเวลา ซึ่งควรทำในทุกกรณีที่การค้นหาสิ้นสุดลงก่อนการจับคู่ครั้งสุดท้ายในแถวเดียว พบ และการค้นหาจะเริ่มต้นในบรรทัดอื่นด้วยวัตถุ RegExp เดียวกัน) ลักษณะการทำงานพิเศษนี้ทำให้สามารถเรียกใช้ exec() ซ้ำๆ เพื่อวนซ้ำการจับคู่นิพจน์ทั่วไปทั้งหมดในบรรทัด ตัวอย่างเช่น:
รูปแบบ Var = /Java/g; var text = "JavaScript สนุกกว่า Java!"; ผลลัพธ์ var; while((result = pattern.exec(text)) != null) ( console.log("Found "" + result + """ + " at position " + result.index + "; การค้นหาครั้งต่อไปจะเริ่มที่ " + รูปแบบ .lastIndex);
อีกวิธีหนึ่งของวัตถุ RegExp คือ test() ซึ่งมีมากกว่านั้นมาก วิธีที่ง่ายกว่าผู้บริหาร() รับสตริงและส่งกลับค่าจริงหากสตริงตรงกับนิพจน์ทั่วไป:
รูปแบบ Var = /java/i; pattern.test("จาวาสคริปต์"); // กลับเป็นจริง
การเรียก test() เทียบเท่ากับการเรียก exec() ซึ่งจะคืนค่าเป็นจริงหาก exec() คืนค่าอย่างอื่นที่ไม่ใช่ค่าว่าง ด้วยเหตุนี้ เมธอด test() จึงทำงานในลักษณะเดียวกับเมธอด exec() เมื่อเรียกใช้ในนิพจน์ทั่วไปทั่วไป โดยจะเริ่มค้นหาสตริงที่ระบุในตำแหน่งที่ระบุโดยคุณสมบัติ LastIndex และหากพบว่าตรงกัน ตั้งค่าคุณสมบัติ LastIndex เป็นหมายเลขตำแหน่งอักขระถัดจากรายการที่ตรงกันโดยตรง ดังนั้น เมื่อใช้เมธอด test() คุณสามารถสร้างวงวนการข้ามเส้นได้ในลักษณะเดียวกับการใช้เมธอด exec()
ไวยากรณ์ของนิพจน์ทั่วไปค่อนข้างซับซ้อนและต้องใช้ความพยายามอย่างมากในการเรียนรู้ คำแนะนำที่ดีที่สุดหนังสือเกี่ยวกับนิพจน์ทั่วไปวันนี้คือหนังสือ "Regular Expressions" ของ J. Friedl ซึ่งช่วยให้ "เรียนรู้ที่จะคิดในนิพจน์ทั่วไป" ตามที่ผู้เขียนกล่าวไว้
แนวคิดพื้นฐานนิพจน์ทั่วไปเป็นวิธีการประมวลผลสตริงหรือลำดับอักขระที่กำหนดรูปแบบข้อความ
ตัวแก้ไข - มีวัตถุประสงค์เพื่อ "สั่งสอน" นิพจน์ทั่วไป
MetaCharacter คืออักขระพิเศษที่ทำหน้าที่เป็นคำสั่งในภาษานิพจน์ทั่วไป
นิพจน์ทั่วไปถูกตั้งค่าเป็นตัวแปรปกติ โดยจะใช้เฉพาะเครื่องหมายทับแทนเครื่องหมายคำพูด เช่น var reg=/reg_expression/
โดยเทมเพลตที่ง่ายที่สุด เราหมายถึงเทมเพลตที่ไม่ต้องใช้อักขระพิเศษใดๆ
สมมติว่างานของเราคือการแทนที่ตัวอักษร "r" ทั้งหมด (เล็กและตัวพิมพ์ใหญ่) ด้วยภาษาละติน อักษรตัวใหญ่"R" ในวลี นิพจน์ทั่วไป.
สร้างเทมเพลต var reg=/р/ และใช้วิธีการ แทนที่เราดำเนินการตามแผนของเรา
var reg=/р/
เอกสาร. เขียน (ผลลัพธ์)
เป็นผลให้เราได้รับบรรทัด - นิพจน์ทั่วไปการแทนที่เกิดขึ้นเฉพาะกับการปรากฏครั้งแรกของตัวอักษร "p" โดยคำนึงถึงกรณีและปัญหา
แต่ผลลัพธ์นี้ไม่ตรงกับเงื่อนไขของงานของเรา... ที่นี่เราต้องการตัวดัดแปลง "g" และ "i" ซึ่งสามารถใช้ได้ทั้งแยกกันและร่วมกัน ตัวแก้ไขเหล่านี้จะวางไว้ที่ส่วนท้ายของรูปแบบนิพจน์ทั่วไป หลังเครื่องหมายทับ และมี ค่าต่อไปนี้:
ตัวดัดแปลง "g" - ตั้งค่าการค้นหาในบรรทัดเป็น "ทั่วโลก" เช่น ในกรณีของเรา การแทนที่จะเกิดขึ้นกับตัวอักษร "p" ทั้งหมดที่เกิดขึ้น ตอนนี้เทมเพลตมีลักษณะดังนี้: var reg=/р/g โดยแทนที่ในโค้ดของเรา
var str="นิพจน์ปกติ"
var reg=/р/g
ผลลัพธ์ var=str.replace(reg, "R")
เอกสาร. เขียน (ผลลัพธ์)
เราได้รับสตริง - นิพจน์ทั่วไป
โมดิฟายเออร์ "i" - ระบุการค้นหาที่ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ในสตริง โดยการเพิ่มโมดิฟายเออร์นี้ลงในเทมเพลต var reg=/р/gi ของเรา หลังจากรันสคริปต์แล้ว เราจะได้ผลลัพธ์ที่ต้องการจากงานของเรา - นิพจน์ทั่วไป
MetaCharacters ระบุประเภทของอักขระของสตริงการค้นหา วิธีล้อมรอบสตริงการค้นหาในข้อความ รวมถึงจำนวนอักขระ แยกประเภทในข้อความที่กำลังดูอยู่ ดังนั้น metaCharacters จึงสามารถแบ่งออกเป็นสามกลุ่ม:
- MetaCharacters สำหรับการค้นหาการแข่งขัน
- อักขระเมตาเชิงปริมาณ
- การวางตำแหน่งอักขระเมตา
ความหมาย | คำอธิบาย | ||
ขอบเขตคำ | ระบุเงื่อนไขที่ควรใช้รูปแบบที่จุดเริ่มต้นหรือจุดสิ้นสุดของคำ | /\ber/ ตรงกัน ข้อผิดพลาด, ไม่ตรงกัน ฮีโร่หรือด้วย ผู้เล่น |
|
ไม่ใช่การจำกัดคำ | ระบุเงื่อนไขที่รูปแบบไม่ถูกดำเนินการที่จุดเริ่มต้นหรือจุดสิ้นสุดของคำ | /\Ber/ ตรงกัน ฮีโร่หรือด้วย ผู้เล่น, ไม่ตรงกัน ข้อผิดพลาด |
|
หมายเลขตั้งแต่ 0 ถึง 9 | /\d\d\d\d/ จับคู่ตัวเลขสี่หลักใดๆ |
||
/\D\D\D\D/ จะไม่ตรงกัน 2005 หรือ 05.กหรือ №126 ฯลฯ |
|||
อักขระว่างตัวเดียว | ตรงกับอักขระช่องว่าง | \over\sbyte\ ตรงกันเท่านั้น เกินไบต์ |
|
อักขระตัวเดียวที่ไม่เว้นว่าง | อักขระเดี่ยวใดๆ ยกเว้นช่องว่าง | \over\Sbyte\ ตรงกัน เกินไบต์หรือด้วย เกิน_ไบต์, ไม่ตรงกัน เกินไบต์หรือ เกินไบต์ |
|
ตัวอักษร ตัวเลข หรือขีดล่าง | /A\w/ ตรงกัน A1หรือด้วย เอบี, ไม่ตรงกัน เอ+ |
||
ไม่ใช่ตัวอักษร ตัวเลข หรือขีดล่าง | /A\W/ ไม่ตรงกัน A1หรือด้วย เอบี, ตรงกับ เอ+ |
||
ตัวละครใดก็ได้ | ป้าย ตัวอักษร ตัวเลข ฯลฯ | /.../ จับคู่อักขระสามตัวใดก็ได้ เอบีซีหรือ !@4 หรือ 1 คิว |
|
ชุดอักขระ | ระบุเงื่อนไขที่ต้องดำเนินการรูปแบบสำหรับการจับคู่อักขระที่อยู่ในวงเล็บเหลี่ยม | /WERTY/ ตรงกัน QWERTY, กับ ความกล้าหาญ |
|
ชุดอักขระที่ไม่รวมอยู่ด้วย | ระบุเงื่อนไขที่ไม่ควรดำเนินการรูปแบบสำหรับการจับคู่อักขระใดๆ ที่อยู่ในวงเล็บเหลี่ยม | /[^QA]WERTY/ ไม่ตรงกัน QWERTY, กับ ความกล้าหาญ |
อักขระที่อยู่ในตาราง "Match Search MetaCharacters" ไม่ควรสับสนกับลำดับอักขระ Escape ที่ใช้ในสตริง เช่น \\t - tab, \\n - ขึ้นบรรทัดใหม่ ฯลฯ
อักขระเมตาเชิงปริมาณจำนวนการแข่งขัน | ||
ศูนย์และ มากกว่าครั้งหนึ่ง | /Ja*vaScript/ ตรงกัน จาวาสคริปต์หรือด้วย จาวาสคริปต์หรือด้วย จาวาสคริปต์, ไม่ตรงกัน จาวาสคริปต์ |
|
ศูนย์หรือครั้งเดียว | /Ja?vaScript/ ตรงกันเท่านั้น จาวาสคริปต์หรือด้วย จาวาสคริปต์ |
|
หนึ่งครั้งหรือมากกว่านั้น | /Ja+vaScript/ ตรงกัน จาวาสคริปต์หรือด้วย จาวาสคริปต์หรือด้วย จาวาสคริปต์, ไม่ตรงกัน จาวาสคริปต์ |
|
n ครั้งพอดี | /Ja(2)vaScript/ ตรงกันเท่านั้น จาวาสคริปต์ |
|
n หรือมากกว่านั้น | /Ja(2,)vaScript/ ตรงกัน จาวาสคริปต์หรือด้วย จาวาสคริปต์, ไม่ตรงกัน จาวาสคริปต์หรือด้วย จาวาสคริปต์ |
|
โดย อย่างน้อย, n ครั้ง แต่ไม่เกิน m ครั้ง | /Ja(2,3)vaScript/ ตรงกันเท่านั้น จาวาสคริปต์หรือด้วย จาวาสคริปต์ |
อักขระแต่ละตัวที่แสดงอยู่ในตาราง MetaCharacter เชิงปริมาณจะนำไปใช้กับอักขระก่อนหน้าหรืออักขระ meta ในนิพจน์ทั่วไป
การวางตำแหน่งอักขระเมตาชุดสุดท้ายอักขระเมตามีวัตถุประสงค์เพื่อระบุตำแหน่งที่จะค้นหา (หากสำคัญ) สำหรับสตริงย่อยที่จุดเริ่มต้นของบรรทัดหรือที่ส่วนท้าย
วิธีการบางอย่างในการทำงานกับเทมเพลตแทนที่ - วิธีนี้เราใช้มันแล้วในตอนต้นของบทความ มันถูกออกแบบมาเพื่อค้นหารูปแบบและแทนที่สตริงย่อยที่พบด้วยสตริงย่อยใหม่
exec - เมธอดนี้ดำเนินการจับคู่สตริงกับรูปแบบที่ระบุโดยเทมเพลต หากการจับคู่รูปแบบล้มเหลว ระบบจะส่งคืน ค่าว่าง- มิฉะนั้น ผลลัพธ์จะเป็นอาร์เรย์ของสตริงย่อยที่ตรงกับรูปแบบที่กำหนด /*องค์ประกอบแรกของอาร์เรย์จะเท่ากับสตริงดั้งเดิมที่ตรงกับรูปแบบที่กำหนด*/
ตัวอย่างเช่น:
var reg=/(\d+).(\d+).(\d+)/
var arr=reg.exec("ฉันเกิดวันที่ 15 กันยายน 1980")
document.write("วันเกิด: ", arr, "< br>")
document.write("วันเกิด: ", arr, "< br>")
document.write("เดือนเกิด: ", arr, "< br>")
document.write("ปีเกิด: ", arr, "< br>")
เป็นผลให้เราได้รับสี่บรรทัด:
วันเกิด: 09/15/1980
วันเกิด: 15
เดือนเกิด: 09
ปีเกิด: 1980
บทความนี้ไม่ได้แสดงความสามารถและความพึงพอใจทั้งหมดของนิพจน์ทั่วไป เพื่อศึกษาปัญหานี้ในเชิงลึก ฉันขอแนะนำให้คุณศึกษาวัตถุ RegExp ฉันยังต้องการดึงความสนใจของคุณไปที่ข้อเท็จจริงที่ว่าไวยากรณ์ของนิพจน์ทั่วไปไม่แตกต่างกันทั้งใน JavaScript และ PHP ตัวอย่างเช่น หากต้องการตรวจสอบว่าป้อนอีเมลอย่างถูกต้องหรือไม่ นิพจน์ทั่วไปสำหรับทั้ง JavaScript และ PHP จะมีลักษณะเหมือนกัน /+@+.(2,3)/i
คลาส RegExp ใน JavaScript เป็นนิพจน์ทั่วไป - วัตถุที่อธิบายรูปแบบอักขระ โดยทั่วไปออบเจ็กต์ RegExp จะถูกสร้างขึ้นโดยใช้ไวยากรณ์ตามตัวอักษรพิเศษที่แสดงด้านล่าง แต่ก็สามารถสร้างได้โดยใช้ตัวสร้าง RegExp() เช่นกัน
ไวยากรณ์ // ใช้ไวยากรณ์ตามตัวอักษรพิเศษ var regex = /pattern /flags ; // ใช้คอนสตรัคเตอร์ var regex = new RegExp("pattern ", "flags "); var regex = new RegExp(/pattern /, "flags ");ค่าพารามิเตอร์:
ธงนิพจน์ทั่วไป| ก | ช่วยให้คุณค้นหาการแข่งขันทั้งหมดแทนที่จะหยุดหลังจากนัดแรก ( ธงการแข่งขันระดับโลก). |
| ฉัน | อนุญาตการจับคู่ที่ไม่คำนึงถึงขนาดตัวพิมพ์ ( ละเว้นธงกรณี). |
| ม | การจับคู่เสร็จสิ้นในหลายแถว อักขระนำหน้าและต่อท้าย (^ และ $) จะถูกประมวลผลในหลายบรรทัด ซึ่งหมายความว่าการจับคู่จะเกิดขึ้นที่จุดเริ่มต้นหรือจุดสิ้นสุดของแต่ละบรรทัด (ตัวคั่น \n หรือ \r) และไม่ใช่เพียงจุดเริ่มต้นหรือจุดสิ้นสุดของบรรทัดทั้งหมด ( ธงหลายบรรทัด). |
| คุณ | รูปแบบจะถูกตีความว่าเป็นลำดับของจุดโค้ด Unicode ( ธงยูนิโค้ด). |
| ย | การจับคู่เกิดขึ้นที่ดัชนีชี้ไปโดยคุณสมบัติ LastIndex ของนิพจน์ทั่วไปนี้ ในขณะที่การจับคู่ไม่ได้ดำเนินการที่ดัชนีภายหลังหรือก่อนหน้า ( ธงเหนียว). |
| . | ช่วยให้คุณค้นหาอักขระหนึ่งตัวที่ไม่ใช่อักขระ บรรทัดใหม่หรืออักขระท้ายบรรทัด (\n, \r, \u2028 หรือ \u2029) |
| \d | ช่วยให้คุณค้นหาสัญลักษณ์ตัวเลขในตัวอักษรละตินพื้นฐาน เทียบเท่ากับการใช้ชุดอักขระ |
| \D | ช่วยให้คุณค้นหาอักขระใดๆ ที่ไม่ใช่ตัวเลขในตัวอักษรละตินพื้นฐาน เทียบเท่ากับชุดอักขระ [^0-9] |
| \s | ช่วยให้คุณค้นหาอักขระช่องว่างตัวเดียว อักขระช่องว่างหมายถึงช่องว่าง แท็บ การป้อนหน้า การป้อนบรรทัด และอื่นๆ อักขระช่องว่างยูนิโค้ด เทียบเท่ากับชุดอักขระ [\f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\ u200a \u2028\u2029\u202f\u205f\u3000]. |
| \ส | ช่วยให้คุณค้นหาอักขระตัวเดียวที่ไม่ใช่ช่องว่าง ช่องว่างหมายถึงช่องว่าง แท็บ ฟีดเพจ ป้อนบรรทัด และอักขระช่องว่าง Unicode อื่นๆ เทียบเท่ากับชุดอักขระ [^ \f\n\r\t\v\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009 \u200a \u2028\u2029\u202f\u205f\u3000]. |
| [\ข] | ช่วยให้คุณค้นหาอักขระ Backspace (อักขระพิเศษ \b, U+0008) |
| \0 | ช่วยให้คุณค้นหาสัญลักษณ์ 0 (ศูนย์) |
| \n | ช่วยให้คุณค้นหาอักขระขึ้นบรรทัดใหม่ |
| \ฉ | ช่วยให้คุณค้นหาอักขระฟีดหน้า |
| \r | ช่วยให้คุณค้นหาอักขระการขึ้นบรรทัดใหม่ |
| \t | ช่วยให้คุณค้นหาอักขระแท็บแนวนอน |
| \v | ช่วยให้คุณค้นหาอักขระแท็บแนวตั้ง |
| \w | ช่วยให้คุณค้นหาอักขระตัวอักษรและตัวเลขในตัวอักษรละตินพื้นฐาน รวมถึงขีดล่างด้วย เทียบเท่ากับชุดอักขระ |
| \ว | ช่วยให้คุณค้นหาอักขระใดๆ ที่ไม่ใช่อักขระจากตัวอักษรละตินพื้นฐาน เทียบเท่ากับชุดอักขระ [^a-Za-z0-9_] |
| \cX | ช่วยให้คุณค้นหาอักขระควบคุมในสตริง โดยที่ X คือตัวอักษรจาก A ถึง Z ตัวอย่างเช่น /\cM/ แทนอักขระ Ctrl-M |
| \xhh | ช่วยให้คุณค้นหาสัญลักษณ์โดยใช้ ค่าเลขฐานสิบหก(hh คือค่าเลขฐานสิบหกสองหลัก) |
| \เอ่อ. | ช่วยให้คุณสามารถค้นหาอักขระโดยใช้การเข้ารหัส UTF-16 (hhhh คือค่าเลขฐานสิบหกสี่หลัก) |
| \u(hhhh) หรือ \u(ฮะๆๆๆ) | ช่วยให้คุณสามารถค้นหาอักขระที่มีค่า Unicode เป็น U+hhhh หรือ U+hhhhh (ค่าฐานสิบหก) เฉพาะเมื่อคุณได้รับธงเท่านั้น |
| \ | ระบุว่าอักขระต่อไปนี้เป็นอักขระพิเศษและไม่ควรตีความตามตัวอักษร สำหรับอักขระที่โดยปกติจะตีความด้วยวิธีพิเศษ ให้ระบุว่าอักขระต่อไปนี้ไม่ใช่อักขระพิเศษ และควรตีความตามตัวอักษร |
| ไม่มี* | การจับคู่จะเกิดขึ้นกับสตริงใดๆ ที่มีอักขระเป็นศูนย์หรือมากกว่านั้น n. |
| n+ | การจับคู่เกิดขึ้นกับสตริงใดๆ ที่มีอักขระอย่างน้อยหนึ่งตัว n. |
| ใช่ไหม? | การจับคู่จะเกิดขึ้นกับสตริงใดๆ ที่มีองค์ประกอบอยู่ข้างหน้า nศูนย์หรือครั้งเดียว |
| ไม่มี(x) | จับคู่สตริงใดๆ ที่มีลำดับอักขระ nจำนวนครั้งที่แน่นอน x. เอ็กซ์ |
| n(x,) | xการเกิดขึ้นขององค์ประกอบก่อนหน้า n. เอ็กซ์ต้องเป็นจำนวนเต็มบวก |
| n(x, y) | จับคู่สตริงใดๆ ที่มีอย่างน้อย xแต่ไม่มากไปกว่าด้วย ยการเกิดขึ้นขององค์ประกอบก่อนหน้า n. เอ็กซ์และ ยต้องเป็นจำนวนเต็มบวก |
| ไม่มี*? ไม่มี+? มะ?? น(x)? น(x,)? น(x,y)? | การเปรียบเทียบเกิดขึ้นโดยการเปรียบเทียบกับปริมาณ *, +, ? และ (...) อย่างไรก็ตามในเวลาเดียวกัน การค้นหาอยู่ระหว่างดำเนินการการเปรียบเทียบขั้นต่ำที่เป็นไปได้ ค่าเริ่มต้นคือโหมด "โลภ" ? ที่ส่วนท้ายของปริมาณช่วยให้คุณสามารถตั้งค่าโหมด "ไม่โลภ" ซึ่งการเปรียบเทียบจะทำซ้ำตามจำนวนขั้นต่ำที่เป็นไปได้ |
| x(?=ย) | ให้คุณเปรียบเทียบได้ xเฉพาะในกรณีที่สำหรับ xควร ย. |
| x(?!y) | ให้คุณเปรียบเทียบได้ xเฉพาะในกรณีที่สำหรับ xไม่ควร ย. |
| x|y | การเปรียบเทียบเกิดขึ้นกับทางเลือกที่ระบุ |
| (เอ็กซ์) | ช่วยให้คุณค้นหาสัญลักษณ์ xและจดจำผลลัพธ์ของการเปรียบเทียบ ("วงเล็บจับ") สตริงย่อยที่ตรงกันสามารถเรียกได้จากองค์ประกอบอาร์เรย์ผลลัพธ์ ..., [n] หรือจากคุณสมบัติของออบเจ็กต์ RegExp ที่กำหนดไว้ล่วงหน้า $1 ..., $9 |
| (?:x) | ช่วยให้คุณค้นหาสัญลักษณ์ xแต่จำผลการแข่งขันไม่ได้ ("วงเล็บไม่จับ") ไม่สามารถเรียกสตริงย่อยที่ตรงกันจากองค์ประกอบอาร์เรย์ผลลัพธ์ ..., [n] หรือจากคุณสมบัติของออบเจ็กต์ RegExp ที่กำหนดไว้ล่วงหน้า $1 ..., $9 |
| \n | การอ้างอิงกลับไปยังสตริงย่อยสุดท้ายที่ตรงกับสตริงที่ n ในวงเล็บในนิพจน์ทั่วไป (จำนวนวงเล็บเริ่มจากซ้ายไปขวา) nต้องเป็นจำนวนเต็มบวก |
