ฉันรู้ว่าเป็นไปได้ที่จะจับคู่คำแล้วย้อนกลับการแข่งขันโดยใช้เครื่องมืออื่น ๆ (เช่นgrep -v) อย่างไรก็ตามเป็นไปได้หรือไม่ที่จะจับคู่บรรทัดที่ไม่มีคำเฉพาะเช่นการhedeใช้นิพจน์ทั่วไป?

การป้อนข้อมูล:

hoho
hihi
haha
hede

รหัส:

grep "<Regex for 'doesn't contain hede'>" input

ผลลัพธ์ที่ต้องการ:

hoho
hihi
haha

ความคิดที่ว่า regex ไม่สนับสนุนการจับคู่ผกผันนั้นไม่เป็นความจริง แต่อย่างใด คุณสามารถเลียนแบบพฤติกรรมนี้ได้โดยใช้การดูเชิงลบ:

^((?!hede).)*$

regex ด้านบนจะจับคู่สตริงใด ๆ หรือบรรทัดที่ไม่มีตัวแบ่งบรรทัดไม่ประกอบด้วยสตริง (ย่อย) 'hede' ดังที่กล่าวมานี้ไม่ใช่สิ่งที่ regex เป็น "ดี" ที่ (หรือควรทำ) แต่ก็ยังเป็นไปได้

และหากคุณต้องการจับคู่ตัวแบ่งบรรทัดด้วยให้ใช้ตัวดัดแปลง DOT-ALL (ตัวต่อท้ายsในรูปแบบต่อไปนี้):

/^((?!hede).)*$/s

หรือใช้แบบอินไลน์:

/(?s)^((?!hede).)*$/

(โดยที่/.../เป็นตัวคั่น regex คือไม่ใช่ส่วนหนึ่งของรูปแบบ)

หากไม่มีตัวปรับ DOT-ALL คุณสามารถเลียนแบบพฤติกรรมเดียวกันกับคลาสอักขระ[\s\S]:

/^((?!hede)[\s\S])*$/

คำอธิบาย

สตริงเป็นเพียงรายการของnตัวละคร ก่อนและหลังอักขระแต่ละตัวจะมีสตริงว่าง ดังนั้นรายการของnอักขระจะมีn+1สตริงว่าง พิจารณาสตริง"ABhedeCD":

    ┌──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┬───┬──┐
S = │e1│ A │e2│ B │e3│ h │e4│ e │e5│ d │e6│ e │e7│ C │e8│ D │e9│
    └──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┴───┴──┘

index    0      1      2      3      4      5      6      7

โดยที่eคือสตริงว่าง Regex (?!hede).มองไปข้างหน้าเพื่อดูว่าไม่มีซับสตริง"hede"ที่จะเห็นหรือไม่และถ้าเป็นเช่น.นั้น การมองไปรอบ ๆ นั้นเรียกว่าการยืนยันความกว้างเป็นศูนย์เพราะพวกมันไม่ใช้อักขระใด ๆ พวกเขายืนยัน / ตรวจสอบบางสิ่งเท่านั้น

ในตัวอย่างของฉันสตริงว่างทั้งหมดจะถูกตรวจสอบก่อนเพื่อดูว่าไม่มีอะไร"hede"เกิดขึ้นก่อนที่อักขระ.(dot) จะใช้หมด regex จะทำเพียงครั้งเดียวดังนั้นมันเป็นห่อในกลุ่มและทำซ้ำศูนย์หรือมากกว่าครั้ง:(?!hede). ((?!hede).)*ในที่สุดจุดเริ่มต้นและจุดสิ้นสุดของอินพุตจะถูกยึดเพื่อให้แน่ใจว่ามีการใช้อินพุตทั้งหมด:^((?!hede).)*$

ในขณะที่คุณสามารถดูการป้อนข้อมูลที่"ABhedeCD"จะล้มเหลวเพราะe3, regex ไม่(?!hede)ล้มเหลว (มีเป็น "hede"ขึ้นข้างหน้า!)

โปรดทราบว่าโซลูชันที่ไม่ได้ขึ้นต้นด้วย “ hede” :

^(?!hede).*$

โดยทั่วไปจะมีประสิทธิภาพมากขึ้นกว่าวิธีการไม่ได้มี “Hede” :

^((?!hede).)*$

อดีตตรวจสอบ "hede" เฉพาะที่ตำแหน่งแรกของสตริงอินพุตมากกว่าที่ทุกตำแหน่ง

หากคุณใช้เพื่อ grep คุณสามารถใช้grep -v hedeเพื่อรับทุกบรรทัดที่ไม่มี hede

การทางพิเศษแห่งประเทศไทยโอ้อ่านคำถามอีกครั้งgrep -vอาจเป็นสิ่งที่คุณหมายถึงโดย "ตัวเลือกเครื่องมือ"

ตอบ:

^((?!hede).)*$

คำอธิบาย:

^จุดเริ่มต้นของสตริง (จัดกลุ่มและจับไปที่ \ 1 (0 หรือมากกว่านั้น (ตรงกับจำนวนที่มากที่สุดเท่าที่เป็นไปได้))
(?!ดูล่วงหน้าเพื่อดูว่าไม่มี

hede สตริงของคุณ

)สิ้นสุดการดูล่วงหน้า .ตัวละครใด ๆ ยกเว้น \ n,
)*จุดสิ้นสุดของ \ 1 (หมายเหตุ: เนื่องจากคุณใช้ตัวระบุปริมาณในการจับภาพนี้จะมีการจัดเก็บการทำซ้ำรูปแบบการจับภาพครั้งสุดท้ายเท่านั้นที่จะถูกเก็บไว้ใน \ 1)
$ก่อนตัวเลือก \ n และจุดสิ้นสุดของสตริง

คำตอบที่ได้รับนั้นสมบูรณ์แบบเป็นเพียงจุดทางวิชาการ:

นิพจน์ทั่วไปในความหมายของวิทยาศาสตร์คอมพิวเตอร์เชิงทฤษฎีไม่สามารถทำเช่นนี้ได้ สำหรับพวกมันมันต้องมีหน้าตาแบบนี้:

^([^h].*$)|(h([^e].*$|$))|(he([^h].*$|$))|(heh([^e].*$|$))|(hehe.+$) 

สิ่งนี้จะจับคู่แบบเต็มเท่านั้น ทำเพื่อการแข่งขันย่อยจะยิ่งน่าอึดอัดใจ

หากคุณต้องการทดสอบ regex ไปเพียงล้มเหลวถ้าสตริงทั้งหมดแมตช์ต่อไปนี้จะทำงาน:

^(?!hede$).*

เช่น - หากคุณต้องการอนุญาตค่าทั้งหมดยกเว้น "foo" (เช่น "foofoo", "barfoo" และ "foobar" จะผ่าน แต่ "foo" จะล้มเหลว) ให้ใช้: ^(?!foo$).*

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

myStr !== 'foo'

คุณสามารถลบล้างนอกการทดสอบได้หากคุณต้องการฟีเจอร์ regex (ที่นี่การทดสอบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่):

!/^[a-f]oo$/i.test(myStr)

โซลูชัน regex ที่ด้านบนของคำตอบนี้อาจมีประโยชน์อย่างไรก็ตามในสถานการณ์ที่จำเป็นต้องใช้การทดสอบ regex เชิงบวก (อาจใช้ API)

FWIW เนื่องจากภาษาปกติ (ภาษาอาคาที่มีเหตุผล) ปิดภายใต้การใช้งานร่วมกันจึงเป็นไปได้ที่จะหานิพจน์ทั่วไป แต่มีเครื่องมือไม่มากที่ใช้สิ่งนี้

Vcsnรองรับผู้ประกอบการนี้ (ซึ่งหมายถึง{c}postfix)

แรกที่คุณกำหนดประเภทของการแสดงออกของคุณ: ป้ายชื่อเป็นตัวอักษร ( lal_char) เพื่อเลือกจากaไปzเช่น (การกำหนดตัวอักษรเมื่อทำงานกับ complementation เป็นของหลักสูตรที่สำคัญมาก) และ "มูลค่า" คำนวณสำหรับแต่ละคำเป็นเพียงบูลีน : trueคำนี้ได้รับการยอมรับfalse, ปฏิเสธ

ใน Python:

In [5]: import vcsn
        c = vcsn.context('lal_char(a-z), b')
        c
Out[5]: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z} → 𝔹

จากนั้นคุณป้อนการแสดงออกของคุณ:

In [6]: e = c.expression('(hede){c}'); e
Out[6]: (hede)^c

แปลงนิพจน์นี้เป็นออโตเมติก:

In [7]: a = e.automaton(); a

ในที่สุดแปลงหุ่นยนต์นี้กลับไปเป็นนิพจน์อย่างง่าย

In [8]: print(a.expression())
        \e+h(\e+e(\e+d))+([^h]+h([^e]+e([^d]+d([^e]+e[^]))))[^]*

ที่+มักจะมีการแสดง|, \eหมายถึงคำที่ว่างเปล่าและ[^]มักจะเขียน.(ตัวอักษรใด ๆ ) ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).*ดังนั้นด้วยบิตของการเขียนใหม่

คุณสามารถดูตัวอย่างนี้ที่นี่และพยายาม Vcsn ออนไลน์มี

ต่อไปนี้เป็นคำอธิบายที่ดีว่าทำไมจึงไม่ง่ายที่จะปฏิเสธ regex โดยพลการ ฉันต้องเห็นด้วยกับคำตอบอื่น ๆ แม้ว่า: ถ้านี่คือสิ่งอื่นที่ไม่ใช่คำถามสมมุติแล้ว regex ไม่ใช่ตัวเลือกที่เหมาะสมที่นี่

ด้วย lookahead เชิงลบนิพจน์ทั่วไปสามารถจับคู่สิ่งที่ไม่มีรูปแบบเฉพาะ นี่คือคำตอบและอธิบายโดย Bart Kiers คำอธิบายที่ดี!

อย่างไรก็ตามด้วยคำตอบของ Bart Kiers ส่วน lookahead จะทดสอบ 1 ถึง 4 ตัวอักษรล่วงหน้าขณะเดียวกัน เราสามารถหลีกเลี่ยงปัญหานี้และปล่อยให้ส่วน lookahead ตรวจสอบข้อความทั้งหมดตรวจสอบให้แน่ใจว่าไม่มี 'hede' จากนั้นส่วนปกติ (. *) สามารถกินข้อความทั้งหมดได้ในคราวเดียว

นี่คือ regex ที่ปรับปรุงใหม่:

/^(?!.*?hede).*$/

โปรดทราบว่า (*?) lazy quantifier ในส่วน lookahead เชิงลบเป็นตัวเลือกคุณสามารถใช้ (*) โลภ quantifier แทนขึ้นอยู่กับข้อมูลของคุณ: หาก 'hede' ปรากฏขึ้นและในช่วงครึ่งแรกของข้อความ จะเร็วขึ้น มิฉะนั้นปริมาณโลภจะเร็วขึ้น อย่างไรก็ตามหาก 'hede' ไม่ปรากฏขึ้นทั้งคู่ก็จะช้าเหมือนกัน

นี่คือรหัสตัวอย่างรหัสการสาธิต

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ lookahead โปรดตรวจสอบบทความดีดี: Mastering Lookahead และ Lookbehind

นอกจากนี้โปรดตรวจสอบRegexGen.jsซึ่งเป็นตัวสร้างนิพจน์ทั่วไปของ JavaScript ที่ช่วยในการสร้างนิพจน์ปกติที่ซับซ้อน ด้วย RegexGen.js คุณสามารถสร้าง regex ด้วยวิธีที่อ่านได้มากขึ้น:

var _ = regexGen;

var regex = _(
    _.startOfLine(),             
    _.anything().notContains(       // match anything that not contains:
        _.anything().lazy(), 'hede' //   zero or more chars that followed by 'hede',
                                    //   i.e., anything contains 'hede'
    ), 
    _.endOfLine()
);

มาตรฐาน

ฉันตัดสินใจที่จะประเมินตัวเลือกที่นำเสนอบางส่วนและเปรียบเทียบประสิทธิภาพของพวกเขารวมถึงใช้คุณสมบัติใหม่บางอย่าง การเปรียบเทียบใน. NET Regex Engine: http://regexhero.net/tester/

ข้อความมาตรฐาน:

7 บรรทัดแรกไม่ควรตรงกันเนื่องจากมีนิพจน์ที่ค้นหาขณะที่ 7 บรรทัดด้านล่างควรตรงกัน!

Regex Hero is a real-time online Silverlight Regular Expression Tester.
XRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex HeroRegex HeroRegex HeroRegex HeroRegex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her Regex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.Regex Hero
egex Hero egex Hero egex Hero egex Hero egex Hero egex Hero Regex Hero is a real-time online Silverlight Regular Expression Tester.
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRegex Hero is a real-time online Silverlight Regular Expression Tester.

Regex Her
egex Hero
egex Hero is a real-time online Silverlight Regular Expression Tester.
Regex Her is a real-time online Silverlight Regular Expression Tester.
Regex Her Regex Her Regex Her Regex Her Regex Her Regex Her is a real-time online Silverlight Regular Expression Tester.
Nobody is a real-time online Silverlight Regular Expression Tester.
Regex Her o egex Hero Regex  Hero Reg ex Hero is a real-time online Silverlight Regular Expression Tester.

ผล:

ผลลัพธ์คือการวนซ้ำต่อวินาทีเนื่องจากค่ามัธยฐานของการวิ่ง 3 ครั้ง - จำนวนที่มากขึ้น = ดีกว่า

01: ^((?!Regex Hero).)*$                    3.914   // Accepted Answer
02: ^(?:(?!Regex Hero).)*$                  5.034   // With Non-Capturing group
03: ^(?>[^R]+|R(?!egex Hero))*$             6.137   // Lookahead only on the right first letter
04: ^(?>(?:.*?Regex Hero)?)^.*$             7.426   // Match the word and check if you're still at linestart
05: ^(?(?=.*?Regex Hero)(?#fail)|.*)$       7.371   // Logic Branch: Find Regex Hero? match nothing, else anything

P1: ^(?(?=.*?Regex Hero)(*FAIL)|(*ACCEPT))  ?????   // Logic Branch in Perl - Quick FAIL
P2: .*?Regex Hero(*COMMIT)(*FAIL)|(*ACCEPT) ?????   // Direct COMMIT & FAIL in Perl

ตั้งแต่. NET ไม่สนับสนุนการกระทำกริยา (* FAIL เป็นต้น) ฉันไม่สามารถทดสอบวิธีแก้ปัญหา P1 และ P2 ได้

สรุป:

ฉันพยายามทดสอบวิธีแก้ปัญหาที่เสนอมากที่สุดการเพิ่มประสิทธิภาพบางคำอาจทำได้สำหรับบางคำ ตัวอย่างเช่นหากตัวอักษรสองตัวแรกของสตริงการค้นหาไม่เหมือนกันคำตอบ 03 สามารถขยายได้เพื่อ ^(?>[^R]+|R+(?!egex Hero))*$ให้ได้รับประสิทธิภาพเล็กน้อย

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

ไม่ใช่ regex แต่ฉันพบว่ามันมีเหตุผลและมีประโยชน์ในการใช้ greps อนุกรมที่มีไพพ์เพื่อกำจัดสัญญาณรบกวน

เช่น. ค้นหาไฟล์ config ของ Apache โดยไม่ต้องคอมเม้นท์ทั้งหมด

grep -v '\#' /opt/lampp/etc/httpd.conf      # this gives all the non-comment lines

และ

grep -v '\#' /opt/lampp/etc/httpd.conf |  grep -i dir

ตรรกะของซีเรียลอนุกรมคือ (ไม่ใช่ความคิดเห็น) และ (ตรงกับ dir)

ด้วยวิธีนี้คุณหลีกเลี่ยงการทดสอบ lookahead ในแต่ละตำแหน่ง:

/^(?:[^h]+|h++(?!ede))*+$/

เทียบเท่ากับ (สำหรับ. net):

^(?>(?:[^h]+|h+(?!ede))*)$

คำตอบเก่า:

/^(?>[^h]+|h+(?!ede))*$/

ดังกล่าว(?:(?!hede).)*เป็นสิ่งที่ดีเพราะสามารถยึดได้

^(?:(?!hede).)*$               # A line without hede

foo(?:(?!hede).)*bar           # foo followed by bar, without hede between them

แต่สิ่งต่อไปนี้จะเพียงพอในกรณีนี้:

^(?!.*hede)                    # A line without hede

การทำให้เข้าใจง่ายนี้พร้อมที่จะเพิ่มส่วนคำสั่ง "AND":

^(?!.*hede)(?=.*foo)(?=.*bar)   # A line with foo and bar, but without hede
^(?!.*hede)(?=.*foo).*bar       # Same

นี่คือวิธีที่ฉันจะทำ:

^[^h]*(h(?!ede)[^h]*)*$

แม่นยำและมีประสิทธิภาพมากกว่าคำตอบอื่น ๆ มันใช้เทคนิคประสิทธิภาพของ"unrolling-the-loop"ของ Friedl และต้องใช้การย้อนรอยน้อยกว่ามาก

หากคุณต้องการจับคู่อักขระเพื่อคัดค้านคำที่คล้ายกับคัดค้านคลาสอักขระ:

ตัวอย่างเช่นสตริง:

<?
$str="aaa        bbb4      aaa     bbb7";
?>

ไม่ได้ใช้:

<?
preg_match('/aaa[^bbb]+?bbb7/s', $str, $matches);
?>

ใช้:

<?
preg_match('/aaa(?:(?!bbb).)+?bbb7/s', $str, $matches);
?>

การแจ้งให้ทราบ"(?!bbb)."ล่วงหน้าไม่ใช่การมองทั้งหลังหรือการมองหน้ามันเป็น lookcurrent ตัวอย่างเช่น:

"(?=abc)abcde", "(?!abc)abcde"

คำตอบยอดนิยมในตัวแปรของฉันที่อ่านได้ง่ายกว่าคือ:

^(?!.*hede)

โดยพื้นฐานแล้ว "จับคู่ที่จุดเริ่มต้นของบรรทัดหากว่าไม่มี" hede "อยู่ในนั้น" - ดังนั้นความต้องการจึงถูกแปลเกือบเป็น regex โดยตรง

แน่นอนว่าเป็นไปได้ที่จะมีข้อกำหนดความล้มเหลวหลายประการ:

^(?!.*(hede|hodo|hada))

รายละเอียด: ^ anchor ทำให้มั่นใจได้ว่าเอ็นจิ้น regex จะไม่ลองการจับคู่ในทุกตำแหน่งในสตริงซึ่งจะจับคู่กับสตริงทั้งหมด

^ anchor ในจุดเริ่มต้นนั้นหมายถึงการแสดงจุดเริ่มต้นของบรรทัด เครื่องมือ grep จับคู่แต่ละบรรทัดทีละครั้งในบริบทที่คุณทำงานกับสตริงหลายบรรทัดคุณสามารถใช้แฟล็ก "m":

/^(?!.*hede)/m # JavaScript syntax

หรือ

(?m)^(?!.*hede) # Inline flag

OP ไม่ได้ระบุหรือ Tagโพสต์เพื่อระบุบริบท (ภาษาการเขียนโปรแกรมเครื่องมือแก้ไข) Regex จะถูกใช้ภายใน

Textpadสำหรับผมบางครั้งผมต้องทำเช่นนี้ในขณะที่แก้ไขไฟล์โดยใช้

Textpad รองรับ Regex บางตัว แต่ไม่รองรับ lookahead หรือ lookbehind ดังนั้นจึงใช้เวลาไม่กี่ขั้นตอน

หากฉันต้องการเก็บทุกบรรทัดที่ไม่มีสตริงhedeฉันจะทำดังนี้:

1. ค้นหา / แทนที่ไฟล์ทั้งหมดเพื่อเพิ่ม "แท็ก" ที่ไม่ซ้ำกันในตอนต้นของแต่ละบรรทัดที่มีข้อความใด ๆ

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. ลบบรรทัดทั้งหมดที่มีสตริงhede(สตริงการแทนที่ว่างเปล่า):

    Search string:<@#-unique-#@>.*hede.*\n  
    Replace string:<nothing>  
    Replace-all  

3. ณ จุดนี้เส้นที่เหลือทั้งหมดอย่าhedeมีสตริง ลบ "แท็ก" ที่ไม่ซ้ำออกจากทุกบรรทัด (สตริงการแทนที่ว่างเปล่า):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

ตอนนี้คุณมีข้อความต้นฉบับที่มีบรรทัดทั้งหมดที่มีการhedeลบ สตริง

หากฉันต้องการทำบางสิ่งบางอย่างไปยังบรรทัดที่ไม่มีสตริงhedeฉันจะทำดังนี้:

1. ค้นหา / แทนที่ไฟล์ทั้งหมดเพื่อเพิ่ม "แท็ก" ที่ไม่ซ้ำกันในตอนต้นของแต่ละบรรทัดที่มีข้อความใด ๆ

    Search string:^(.)  
    Replace string:<@#-unique-#@>\1  
    Replace-all  

2. สำหรับทุกบรรทัดที่มีสตริงhedeเอา "แท็ก" ที่ไม่ซ้ำออก:

    Search string:<@#-unique-#@>(.*hede)
    Replace string:\1  
    Replace-all  

3. ณ จุดนี้ทุกบรรทัดที่ขึ้นต้นด้วยไม่ซ้ำกัน "แท็ก", อย่าhedeมีสตริง ตอนนี้ฉันสามารถทำบางสิ่งบางอย่างของฉันไปที่บรรทัดเหล่านั้นเท่านั้น

4. เมื่อเสร็จแล้วฉันจะลบ "แท็ก" ที่ไม่ซ้ำออกจากทุกบรรทัด (สตริงการแทนที่ว่างเปล่า):

    Search string:<@#-unique-#@>
    Replace string:<nothing>  
    Replace-all  

เนื่องจากไม่มีใครให้คำตอบกับคำถามโดยตรง ที่ถามฉันจะทำ

คำตอบคือด้วย POSIX grepมันเป็นไปไม่ได้ที่จะตอบสนองคำขอนี้:

grep "<Regex for 'doesn't contain hede'>" input

เหตุผลก็คือ POSIX grepจำเป็นต้องใช้กับนิพจน์ปกติพื้นฐานเท่านั้นเท่านั้นซึ่งไม่ทรงพลังเพียงพอสำหรับการทำภารกิจนั้นให้สำเร็จ (ไม่สามารถแยกวิเคราะห์ภาษาปกติได้เนื่องจากไม่มีการสลับและวงเล็บ)

อย่างไรก็ตาม GNU grepใช้ส่วนขยายที่อนุญาต โดยเฉพาะอย่างยิ่ง\|เป็นตัวดำเนินการสำรองในการนำ BREs ไปใช้ของ GNU \(และ\)เป็นเครื่องหมายวงเล็บ หากเอ็นจิ้นนิพจน์ทั่วไปของคุณรองรับการสับเปลี่ยนวงเล็บเหลี่ยมนิพจน์วงเล็บและดาว Kleene และสามารถยึดกับจุดเริ่มต้นและจุดสิ้นสุดของสตริงนั่นคือทั้งหมดที่คุณต้องการสำหรับวิธีนี้ อย่างไรก็ตามโปรดทราบว่าชุดเชิงลบ[^ ... ]มีความสะดวกมากนอกเหนือจากชุดนั้นเพราะมิฉะนั้นคุณจะต้องแทนที่ด้วยการแสดงออกของแบบฟอร์ม(a|b|c| ... )ที่แสดงรายการตัวละครทุกตัวที่ไม่ได้อยู่ในชุดซึ่งน่าเบื่อมากและยาวเกินไปดังนั้นยิ่งถ้า ชุดอักขระทั้งหมดคือ Unicode

ด้วย GNU grepคำตอบจะเป็นดังนี้:

grep "^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$" input

(พบกับGrailและการเพิ่มประสิทธิภาพบางอย่างด้วยมือ)

คุณยังสามารถใช้เครื่องมือที่ใช้Extended Regular Expressionเช่นegrepเพื่อกำจัดแบ็กสแลช:

egrep "^([^h]|h(h|eh|edh)*([^eh]|e[^dh]|ed[^eh]))*(|h(h|eh|edh)*(|e|ed))$" input

นี่คือสคริปต์สำหรับทดสอบ (โปรดสังเกตว่ามันจะสร้างไฟล์testinput.txtในไดเรกทอรีปัจจุบัน):

#!/bin/bash
REGEX="^\([^h]\|h\(h\|eh\|edh\)*\([^eh]\|e[^dh]\|ed[^eh]\)\)*\(\|h\(h\|eh\|edh\)*\(\|e\|ed\)\)$"

# First four lines as in OP's testcase.
cat > testinput.txt <<EOF
hoho
hihi
haha
hede

h
he
ah
head
ahead
ahed
aheda
ahede
hhede
hehede
hedhede
hehehehehehedehehe
hedecidedthat
EOF
diff -s -u <(grep -v hede testinput.txt) <(grep "$REGEX" testinput.txt)

ในระบบของฉันมันพิมพ์:

Files /dev/fd/63 and /dev/fd/62 are identical

อย่างที่คาดไว้.

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

ในที่สุดตามที่ทุกคนได้กล่าวไว้หากเอ็นจิ้นนิพจน์ปกติของคุณรองรับ lookahead เชิงลบนั่นจะทำให้งานง่ายขึ้นมาก ตัวอย่างเช่นด้วย GNU grep:

grep -P '^((?!hede).)*$' input

อัปเดต:ฉันเพิ่งค้นพบไลบรารี่ OfficialTheory ที่ยอดเยี่ยมของ Kendall Hopkins ซึ่งเขียนด้วย PHP ซึ่งมีฟังก์ชั่นคล้ายกับ Grail การใช้และตัวขยายเสียงที่เขียนด้วยตัวเองฉันสามารถเขียนตัวสร้างออนไลน์ของนิพจน์ปกติเชิงลบที่ให้วลีป้อนข้อมูล (รองรับเฉพาะตัวอักษรและตัวเลขและอักขระเว้นวรรคในขณะนี้): http://www.formauri.es/personal/ pgimeno / อื่น ๆ / ไม่แสวงหาผลการแข่งขัน regex /

สำหรับhedeมันจะออกผลลัพธ์:

^([^h]|h(h|e(h|dh))*([^eh]|e([^dh]|d[^eh])))*(h(h|e(h|dh))*(ed?)?)?$

ซึ่งเทียบเท่ากับข้างต้น

นับตั้งแต่เปิดตัว ruby-2.4.1 เราสามารถใช้งานใหม่ได้ Absent Operatorในการแสดงผลปกติของรูบี้

จากเอกสารอย่างเป็นทางการ

(?~abc) matches: "", "ab", "aab", "cccc", etc.
It doesn't match: "abc", "aabc", "ccccabc", etc.

ดังนั้นในกรณีของคุณ^(?~hede)$ทำงานให้คุณ

2.4.1 :016 > ["hoho", "hihi", "haha", "hede"].select{|s| /^(?~hede)$/.match(s)}
 => ["hoho", "hihi", "haha"]

ผ่านคำกริยา PCRE (*SKIP)(*F)

^hede$(*SKIP)(*F)|^.*$

นี่จะข้ามบรรทัดที่มีสตริงที่แน่นอน hedeตรงทั้งหมดและตรงกับบรรทัดที่เหลือทั้งหมด

การสาธิต

การดำเนินการของชิ้นส่วน:

ขอให้เราพิจารณา regex ข้างต้นโดยแยกออกเป็นสองส่วน

1. ส่วนก่อน|สัญลักษณ์ ส่วนที่ไม่ควรถูกจับคู่

   ^hede$(*SKIP)(*F)

2. ส่วนหลัง|สัญลักษณ์ ส่วนที่ควรจะจับคู่

   ^.*$

ส่วนที่ 1

เอ็นจิ้น Regex จะเริ่มการทำงานจากส่วนแรก

^hede$(*SKIP)(*F)

คำอธิบาย:

• ^ ยืนยันว่าเราเป็นจุดเริ่มต้น
• hede จับคู่สตริง hede
• $ ยืนยันว่าเราอยู่ท้ายบรรทัด

ดังนั้นบรรทัดที่มีสตริงhedeจะจับคู่ เมื่อเอ็นจิ้น regex เห็นสิ่งต่อไปนี้(*SKIP)(*F)( หมายเหตุ: คุณสามารถเขียน(*F)เป็น(*FAIL) ) กริยามันจะข้ามและทำให้การแข่งขันล้มเหลว |เรียกว่าการเปลี่ยนแปลงหรือตรรกะหรือผู้ประกอบการเพิ่มถัด PCRE กริยาซึ่ง inturn hedeตรงกับเขตแดนทั้งหมดที่มีอยู่ระหว่างแต่ละคนและตัวละครทุกตัวในทุกสายยกเว้นสายมีสตริงที่แน่นอน ดูการสาธิตที่นี่ นั่นคือพยายามจับคู่อักขระจากสตริงที่เหลือ ตอนนี้จะดำเนินการ regex ในส่วนที่สอง

ส่วนที่ 2

^.*$

คำอธิบาย:

• ^ ยืนยันว่าเราเป็นจุดเริ่มต้น นั่นคือมันตรงกับทุกบรรทัดเริ่มยกเว้นหนึ่งในhedeบรรทัด ดูการสาธิตที่นี่

• .*ในโหมด Multiline .จะจับคู่กับอักขระใด ๆ ยกเว้นอักขระขึ้นบรรทัดใหม่หรืออักขระขึ้นบรรทัดใหม่ และ*จะทำซ้ำตัวอักษรก่อนหน้าเป็นศูนย์หรือมากกว่าครั้ง ดังนั้น.*จะตรงกับสายทั้งหมด ดูตัวอย่างได้ที่นี่ที่นี่

  เฮ้ทำไมคุณเพิ่ม * แทน. +?

  เพราะ.*จะจับคู่บรรทัดว่าง แต่.+จะไม่จับคู่ว่าง เราต้องการจับคู่ทุกบรรทัดยกเว้นhedeอาจมีความเป็นไปได้ของบรรทัดว่างในอินพุตเช่นกัน ดังนั้นคุณต้องใช้แทน.* จะซ้ำอักขระก่อนหน้าอย่างน้อยหนึ่งครั้ง ดูตรงบรรทัดที่ว่างเปล่าที่นี่.+.+.*

• $ จุดสิ้นสุดของจุดยึดบรรทัดไม่จำเป็นที่นี่

มันอาจจะรักษาได้ดีกว่าสำหรับ regexes สองตัวในโค้ดของคุณหนึ่งอันเพื่อทำการจับคู่ครั้งแรกและถ้ามันจับคู่รัน regex ที่สองเพื่อตรวจสอบกรณีที่ผิดปกติที่คุณต้องการบล็อกตัวอย่างเช่น^.*(hede).*มีตรรกะที่เหมาะสมในรหัสของคุณ

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

TXR ภาษาสนับสนุนการปฏิเสธ regex

$ txr -c '@(repeat)
@{nothede /~hede/}
@(do (put-line nothede))
@(end)'  Input

ตัวอย่างที่ซับซ้อนมากขึ้น: จับคู่ทุกบรรทัดที่ขึ้นต้นด้วยaและลงท้ายด้วยzแต่ไม่มีสตริงย่อยhede:

$ txr -c '@(repeat)
@{nothede /a.*z&~.*hede.*/}
@(do (put-line nothede))
@(end)' -
az         <- echoed
az
abcz       <- echoed
abcz
abhederz   <- not echoed; contains hede
ahedez     <- not echoed; contains hede
ace        <- not echoed; does not end in z
ahedz      <- echoed
ahedz

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

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

^(?!(?=.*\bhede\b)).*$

มีขอบเขตของคำ

นิพจน์นั้นอธิบายไว้ที่แผงด้านบนขวาของregex101.comหากคุณต้องการสำรวจ / ทำให้ง่ายขึ้น / แก้ไขและในลิงค์นี้คุณสามารถดูว่าจะจับคู่กับอินพุตตัวอย่างบางตัวได้อย่างไรหากคุณต้องการ

วงจร RegEx

jex.imเห็นภาพการแสดงออกปกติ:

ฟังก์ชั่นด้านล่างจะช่วยให้คุณได้รับผลลัพธ์ที่ต้องการ

<?PHP
      function removePrepositions($text){

            $propositions=array('/\bfor\b/i','/\bthe\b/i'); 

            if( count($propositions) > 0 ) {
                foreach($propositions as $exceptionPhrase) {
                    $text = preg_replace($exceptionPhrase, '', trim($text));

                }
            $retval = trim($text);

            }
        return $retval;
    }


?>

^ ((?! hede).) * $ เป็นคำตอบที่สวยงามยกเว้นเนื่องจากมันใช้อักขระคุณจะไม่สามารถรวมเข้ากับเกณฑ์อื่นได้ ตัวอย่างเช่นสมมติว่าคุณต้องการตรวจสอบการไม่มี "hede" และ "haha" วิธีนี้ใช้ได้ผลเพราะจะไม่ใช้ตัวอักษร:

^ (?!. \ bhede \ b) (? =. \ bhaha \ b)

วิธีใช้คำกริยาควบคุมการย้อนรอยของ PCRE เพื่อจับคู่บรรทัดที่ไม่มีคำ

นี่เป็นวิธีที่ฉันไม่เคยเห็นมาก่อน:

/.*hede(*COMMIT)^|/

มันทำงานอย่างไร

ก่อนอื่นจะพยายามหา "hede" ที่ใดที่หนึ่งในบรรทัด หากประสบความสำเร็จ ณ จุดนี้(*COMMIT)บอกเครื่องยนต์ถึงไม่เพียง แต่ไม่ย้อนรอยในกรณีที่เกิดความล้มเหลว แต่ยังไม่พยายามทำการจับคู่เพิ่มเติมในกรณีนั้น จากนั้นเราพยายามจับคู่สิ่งที่ไม่สามารถจับคู่ได้ (ในกรณีนี้^)

หากบรรทัดไม่มี "hede" ดังนั้นทางเลือกที่สอง subpattern ว่างตรงกับสตริงหัวเรื่อง

วิธีนี้ไม่มีประสิทธิภาพมากกว่า lookahead เชิงลบ แต่ฉันคิดว่าฉันจะทิ้งมันไว้ที่นี่ในกรณีที่มีคนพบว่ามันเก๋และหามันใช้สำหรับแอปพลิเคชันอื่นที่น่าสนใจกว่า

ทางออกที่ง่ายกว่าคือใช้ตัวดำเนินการที่ไม่ใช่!

คำสั่งifของคุณจะต้องตรงกับ "มี" และไม่ตรงกับ "แยก"

var contains = /abc/;
var excludes =/hede/;

if(string.match(contains) && !(string.match(excludes))){  //proceed...

ฉันเชื่อว่านักออกแบบของ RegEx คาดว่าจะใช้งานตัวดำเนินการไม่ได้

บางทีคุณอาจพบสิ่งนี้บน Google ในขณะที่พยายามเขียน regex ที่สามารถจับคู่เซ็กเมนต์ของบรรทัด (ตรงข้ามกับทั้งบรรทัด) ซึ่งไม่ได้ซับสตริง เอาฉันสักครู่เพื่อคิดออกดังนั้นฉันจะแบ่งปัน:

รับสาย: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

ฉันต้องการจับคู่ <span>แท็กที่ไม่มีสตริงย่อย "ไม่ดี"

/<span(?:(?!bad).)*?>จะจับคู่<span class=\"good\">และ<span class=\"ugly\">และ

โปรดสังเกตว่ามีวงเล็บสองชุด (เลเยอร์):

• ด้านในสุดใช้สำหรับการมองเชิงลบ (ไม่ใช่กลุ่มการจับ)
• ด้านนอกสุดถูกตีความโดย Ruby ในฐานะกลุ่มการดักจับ แต่เราไม่ต้องการให้เป็นกลุ่มการดักจับดังนั้นฉันจึงเพิ่ม?: ตอนนี้มันเริ่มแล้วและมันจะไม่ถูกตีความว่าเป็นกลุ่มการดักจับอีกต่อไป

ตัวอย่างในทับทิม:

s = '<span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>'
s.scan(/<span(?:(?!bad).)*?>/)
# => ["<span class=\"good\">", "<span class=\"ugly\">"]

ด้วยConyEditคุณสามารถใช้บรรทัดคำสั่งcc.gl !/hede/เพื่อรับบรรทัดที่ไม่มีการจับคู่ regex หรือใช้บรรทัดคำสั่งcc.dl /hede/เพื่อลบบรรทัดที่มีการจับคู่ regex พวกเขามีผลเหมือนกัน

ฉันต้องการเพิ่มอีกตัวอย่างหนึ่งหากคุณพยายามจับคู่ทั้งบรรทัดที่มีสตริงXแต่ไม่มีสตริงY Y

ตัวอย่างเช่นสมมติว่าเราต้องการตรวจสอบว่า URL / สตริงของเรามี " Delicious-treats " ตราบใดที่มันไม่มี " chocolate " อยู่ด้วย

รูปแบบ regex นี้จะใช้งานได้ (ทำงานใน JavaScript ด้วย)

^(?=.*?tasty-treats)((?!chocolate).)*$

(ตัวอย่างโกลบอลแฟล็กหลายบรรทัด)

ตัวอย่างแบบโต้ตอบ: https://regexr.com/53gv4

ไม้ขีด

(URL เหล่านี้มี "Delicious-treats" และยังไม่มี "chocolate")

• example.com/tasty-treats/strawberry-ice-cream
• example.com/desserts/tasty-treats/banana-pudding
• example.com/tasty-treats-overview

ไม่ตรงกัน

(URL เหล่านี้มี "ช็อคโกแลต" อยู่ที่ไหนสักแห่ง - ดังนั้นพวกเขาจะไม่ตรงกันแม้ว่าจะมี "อร่อย - ถือว่า")

• example.com/tasty-treats/chocolate-cake
• example.com/home-cooking/oven-roasted-chicken
• example.com/tasty-treats/banana-chocolate-fudge
• example.com/desserts/chocolate/tasty-treats
• example.com/chocolate/tasty-treats/desserts