นิพจน์ทั่วไปเป็นเครื่องมือที่มีประสิทธิภาพในคลังแสงของโปรแกรมเมอร์ แต่มีบางกรณีที่ไม่ใช่ตัวเลือกที่ดีที่สุดหรือแม้แต่เป็นอันตรายทันที

ตัวอย่างง่ายๆ # 1 คือการแยกวิเคราะห์ HTML ด้วย regexpซึ่งเป็นถนนที่รู้จักกันดีในข้อบกพร่องมากมาย อาจเป็นเช่นนี้ยังมีคุณสมบัติในการแยกโดยทั่วไป

แต่มีพื้นที่อื่นที่ไม่ต้องไปสำหรับการแสดงผลปกติหรือไม่?

ป.ล. : " คำถามที่คุณถามปรากฏเป็นเรื่องส่วนตัวและมีแนวโน้มที่จะถูกปิด " - ดังนั้นฉันต้องการเน้นย้ำว่าฉันสนใจตัวอย่างที่ทราบว่าการใช้ regexps ก่อให้เกิดปัญหา

อย่าใช้นิพจน์ทั่วไป:

• เมื่อมีการแยกวิเคราะห์

นี้ไม่ได้ จำกัด การHTML XML ที่ถูกต้องง่ายไม่สามารถแยกวิเคราะห์ด้วยนิพจน์ปกติได้อย่างสมเหตุสมผลแม้ว่าคุณจะรู้สคีมาและคุณก็รู้ว่ามันจะไม่มีวันเปลี่ยนแปลง

อย่าพยายามยกตัวอย่างเช่นแยกรหัส C # แหล่งที่มา แยกมันแทนเพื่อให้ได้โครงสร้างต้นไม้ที่มีความหมายหรือโทเค็น

• โดยทั่วไปเมื่อคุณมีเครื่องมือที่ดีกว่าในการทำงานของคุณ

ถ้าคุณต้องค้นหาจดหมายทั้งตัวเล็กและตัวใหญ่ล่ะ? หากคุณรักการแสดงออกปกติคุณจะใช้พวกเขา แต่มันจะง่ายกว่า / เร็วกว่า / อ่านได้โดยใช้การค้นหาสองรายการใช่หรือไม่? โอกาสอยู่ในภาษาส่วนใหญ่คุณจะได้รับประสิทธิภาพที่ดีขึ้นและทำให้โค้ดของคุณอ่านง่ายขึ้น

ตัวอย่างเช่นโค้ดตัวอย่างในคำตอบของ Ingo เป็นตัวอย่างที่ดีเมื่อคุณต้องไม่ใช้นิพจน์ทั่วไป เพียงแค่ค้นหาแล้วสำหรับfoobar

• เมื่อแยกวิเคราะห์การเขียนของมนุษย์

ตัวอย่างที่ดีคือตัวกรองอนาจาร ไม่เพียง แต่เป็นความคิดที่ไม่ดีโดยทั่วไปที่จะนำไปใช้ แต่คุณอาจถูกล่อลวงให้ทำโดยใช้นิพจน์ทั่วไปและคุณจะทำผิด มีวิธีมากมายที่มนุษย์สามารถเขียนคำตัวเลขประโยคและจะเข้าใจโดยมนุษย์อื่น แต่ไม่ใช่การแสดงออกปกติของคุณ ดังนั้นแทนที่จะจับความหยาบคายที่แท้จริงการแสดงออกปกติของคุณจะใช้เวลาของเธอทำร้ายผู้ใช้คนอื่น

• เมื่อตรวจสอบข้อมูลบางประเภท

ตัวอย่างเช่นอย่าตรวจสอบที่อยู่อีเมลผ่านนิพจน์ทั่วไป ในกรณีส่วนใหญ่คุณจะทำผิด ในกรณีที่หายากที่คุณจะทำมันขวาและจบด้วย 6 343 อักขระยาวเข้ารหัสสยองขวัญ

• เมื่อคุณไม่มีเครื่องมือที่เหมาะสมหรือไม่สนใจรหัสที่สะอาด

หากไม่มีเครื่องมือที่เหมาะสมคุณจะทำผิดพลาด และคุณจะสังเกตเห็นพวกเขาในช่วงเวลาสุดท้ายหรืออาจจะไม่เคย หากคุณไม่สนใจรหัสที่สะอาดคุณจะต้องเขียนสตริงยี่สิบบรรทัดโดยไม่มีความคิดเห็นไม่มีช่องว่างไม่มีการขึ้นบรรทัดใหม่

• เมื่อรหัสของคุณจะถูกอ่าน และจากนั้นอ่านอีกครั้งและอีกครั้งและอีกครั้งทุกครั้งโดยนักพัฒนาที่แตกต่างกัน

อย่างจริงจังถ้าฉันใช้รหัสของคุณและต้องตรวจสอบหรือแก้ไขมันฉันไม่ต้องการใช้เวลาหนึ่งสัปดาห์ในการพยายามทำความเข้าใจสัญลักษณ์ที่มีความยาวยี่สิบบรรทัด

สิ่งที่สำคัญที่สุดเมื่อภาษาที่คุณจะแยกไม่ได้เป็นภาษาปกติ

HTML คือไม่เป็นภาษาปกติและแยกกับการแสดงออกปกติคือไม่ได้เป็นไปได้ (ไม่เพียง แต่ยากหรือถนนรหัสรถม้าชนิดเล็ก)

ใน stackoverflow มักจะเห็นคนถาม regexes ที่ค้นหาว่าสตริงที่กำหนดไม่ได้มีนี้หรือว่า นี่คือ IMHO เพื่อย้อนกลับวัตถุประสงค์ของการแสดงออกปกติ แม้ว่าจะมีวิธีแก้ปัญหาอยู่ (โดยใช้การตรวจสอบเชิงลบหรือการยืนยันสิ่งต่าง ๆ ) แต่ก็มักจะดีกว่าการใช้ regex สำหรับสิ่งที่มันถูกสร้างขึ้นมาและจัดการกรณีเชิงลบด้วยตรรกะโปรแกรม

ตัวอย่าง:

# bad
if (/complicated regex that assures the string does NOT conatin foo|bar/) {
    # do something
}

# appropriate
if (/foo|bar/) {
    # error handling
} else {
    # do something
}

สองกรณี:

เมื่อมีวิธีที่ง่ายกว่า

• ภาษาส่วนใหญ่มีฟังก์ชั่นง่าย ๆ เช่น INSTR เพื่อตรวจสอบว่าสตริงหนึ่งเป็นชุดย่อยของอีกสตริงหรือไม่ หากนั่นคือสิ่งที่คุณต้องการทำใช้ฟังก์ชั่นที่ง่ายขึ้น อย่าเขียนนิพจน์ปกติของคุณเอง

• หากมีไลบรารีสำหรับดำเนินการจัดการสตริงที่ซับซ้อนให้ใช้แทนการเขียนนิพจน์ปกติของคุณเอง

เมื่อการแสดงออกปกติไม่ได้ทรงพลังเพียงพอ

• หากคุณต้องการใช้เครื่องมือแยกวิเคราะห์ใช้โปรแกรมแยกวิเคราะห์

นิพจน์ทั่วไปไม่สามารถระบุโครงสร้างแบบเรียกซ้ำได้ นี่เป็นข้อ จำกัด พื้นฐาน

ใช้ JSON - มันเป็นรูปแบบที่ค่อนข้างเรียบง่าย แต่เนื่องจากวัตถุอาจมีวัตถุอื่น ๆ ที่เป็นค่าสมาชิก (ความลึกโดยพลการ) ไวยากรณ์นั้นวนซ้ำและไม่สามารถแยกวิเคราะห์โดย regex ในขณะที่ CSV สามารถแยกวิเคราะห์โดย regex'es เนื่องจากไม่มีโครงสร้างแบบเรียกซ้ำ

ในการแสดงออกปกติสั้น ๆ ไม่อนุญาตให้รูปแบบที่จะอ้างถึงตัวเอง คุณไม่สามารถพูดได้: ณ จุดนี้ในไวยากรณ์ตรงกับรูปแบบทั้งหมดอีกครั้ง หากต้องการใช้อีกวิธีหนึ่งนิพจน์ทั่วไปจะจับคู่กับเชิงเส้นเท่านั้นซึ่งไม่มีสแต็กที่จะอนุญาตให้ติดตามว่ามันเป็นรูปแบบซ้อนกันหรือไม่

โปรดทราบว่าไม่มีอะไรเกี่ยวข้องกับรูปแบบที่ซับซ้อนหรือซับซ้อน S-expressions นั้นง่ายจริงๆ แต่ไม่สามารถแยกวิเคราะห์ด้วย regex ในทางตรงกันข้าม CSS2 เป็นภาษาที่ค่อนข้างซับซ้อน แต่ไม่มีโครงสร้างแบบเรียกซ้ำและสามารถแยกวิเคราะห์ด้วย regex (แม้ว่าสิ่งนี้จะไม่เป็นจริงสำหรับ CSS3 เนื่องจากการแสดงออกของ CSS ซึ่งมีไวยากรณ์ซ้ำ)

ดังนั้นจึงไม่ใช่เพราะมันน่าเกลียดหรือซับซ้อนหรือมีข้อผิดพลาดในการแยกวิเคราะห์ HTML โดยใช้ regex เท่านั้น มันก็คือว่ามันเป็นเพียงไปไม่ได้

หากคุณต้องการแยกวิเคราะห์รูปแบบที่มีโครงสร้างแบบเรียกซ้ำคุณต้องเพิ่มการใช้นิพจน์ปกติด้วยสแต็กอย่างน้อยเพื่อติดตามระดับของโครงสร้างแบบเรียกซ้ำ โดยทั่วไปนี่เป็นวิธีการแยกวิเคราะห์ นิพจน์ทั่วไปใช้เพื่อรับรู้ส่วน "เชิงเส้น" ในขณะที่รหัสที่กำหนดเองนอก regex ใช้เพื่อติดตามโครงสร้างที่ซ้อนกัน

โดยทั่วไปการแยกวิเคราะห์เช่นนี้จะถูกแยกเป็นระยะ ๆ โทเค็นไลเซชันเป็นเฟสแรกที่นิพจน์ทั่วไปถูกใช้เพื่อแบ่งอินพุตเป็นลำดับของ "โทเค็น" เช่นคำเครื่องหมายวรรคตอนวงเล็บเป็นต้นการแยกเป็นเฟสถัดไปที่โทเค็นเหล่านี้จะถูกวิเคราะห์เป็นโครงสร้างลำดับชั้นต้นไม้ไวยากรณ์

ดังนั้นเมื่อคุณได้ยินว่า HTML หรือ C # ไม่สามารถแยกวิเคราะห์โดยนิพจน์ทั่วไปให้ระวังว่านิพจน์ทั่วไปยังคงเป็นส่วนสำคัญของตัวแยกวิเคราะห์ คุณไม่สามารถแยกวิเคราะห์ภาษาดังกล่าวโดยใช้นิพจน์ทั่วไปเท่านั้นและไม่มีรหัสตัวช่วย