S├Âzc├╝k i├žermeyen bir ├žizgiyle e┼čle┼čmek i├žin normal ifade


Al─▒nan cevaba git


Bir kelimeyle e┼čle┼čmenin ve ard─▒ndan di─čer ara├žlar─▒ kullanarak e┼čle┼čmeleri tersine ├ževirmenin m├╝mk├╝n oldu─čunu biliyorum (├Ârn. grep -v ). Bununla birlikte, ├Ârne─čin hede normal bir ifade kullanarak , belirli bir kelime i├žermeyen sat─▒rlar─▒ e┼čle┼čtirmek m├╝mk├╝n m├╝?

Giri┼č:

 hoho
hihi
haha
hede
 

Kod:

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

Istenilen ├ž─▒kt─▒:

 hoho
hihi
haha
 

4083









Cevap say─▒s─▒n─▒ say: 29






Regex'in ters e┼čle┼čmeyi desteklemedi─či fikri tam olarak do─čru de─čildir. Olumsuz g├Âr├╝n├╝┼čleri kullanarak bu davran─▒┼č─▒ taklit edebilirsiniz:

 ^((?!hede).)*$
 

Regex yukar─▒da, bir ├žizgi ara vermeden herhangi bir dize veya sat─▒rla ayn─▒ olacak de─čil (alt) dize 'hede' i├žeren. Belirtildi─či gibi, bu regex'in "iyi" oldu─ču bir ┼čey de─čildir (ya da yapmal─▒), ama yine de m├╝mk├╝nd├╝r.

Sat─▒r sonu karakterlerini de e┼čle┼čtirmeniz gerekiyorsa, DOT-ALL de─či┼čtiricisini kullan─▒n ( s a┼ča─č─▒daki d├╝zende izleyen):

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

veya sat─▒r i├ži kullan─▒n:

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

(burada /.../ regex s─▒n─▒rlay─▒c─▒lar─▒, yani modelin bir par├žas─▒ de─čil)

DOT-ALL de─či┼čtiricisi mevcut de─čilse, karakter s─▒n─▒f─▒yla ayn─▒ davran─▒┼č─▒ taklit edebilirsiniz [\s\S] :

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

a├ž─▒klama

Bir dize sadece bir n karakter listesidir . ├ľnce ve her karakterden sonra bo┼č bir dize var. B├Âylece bir n karakter listesi n+1 bo┼č dizeleri olacakt─▒r . Dizeyi d├╝┼č├╝n├╝n "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
 

nerede e '─▒n bo┼č dizelerdir. Regex (?!hede). , g├Âr├╝lecek bir alt dize olup olmad─▒─č─▒n─▒ g├Ârmek i├žin ileri bakar "hede" ve bu durumda (ba┼čka bir ┼čey g├Âr├╝l├╝rse), o zaman . (nokta) bir sat─▒r sonu d─▒┼č─▒nda herhangi bir karakterle e┼čle┼čir. ├çevreye s─▒f─▒r geni┼člik iddias─▒ da denir, ├ž├╝nk├╝ hi├ž karakter t├╝ketmezler . Sadece bir ┼čeyi iddia eder / onaylarlar.

Bu nedenle, ├Ârne─čime g├Âre, her bo┼č dize ilk "hede" ├Ânce bir karakter . (nokta) taraf─▒ndan t├╝ketilmeden ├Ânce, ileride bir ┼čey olup olmad─▒─č─▒n─▒ g├Ârmek i├žin do─črulan─▒r . Regex (?!hede). s─▒f─▒r veya daha fazla kez bir grup sar─▒lm─▒┼č ve tekrarlan─▒r, b├Âylece yaln─▒zca bir kez yapaca─č─▒z: ((?!hede).)* . Son olarak, t├╝m giri┼čin t├╝ketildi─činden emin olmak i├žin giri┼čin ba┼člang─▒c─▒ ve sonu ba─člant─▒l─▒d─▒r: ^((?!hede).)*$

G├Ârd├╝─č├╝n├╝z gibi, giri┼č "ABhedeCD" nedeniyle ba┼čar─▒s─▒z olur e3 regex, (?!hede) ba┼čar─▒s─▒z (orada oldu─čunu "hede" ─░lerideki!).


5574







Sol├╝syon o Not gelmez ile ba┼člar ÔÇťHedeÔÇŁ :

 ^(?!hede).*$
 

genellikle ├žok daha verimli ├ž├Âz├╝m├╝ne k─▒yasla vermez i├žeriyor ÔÇťhedeÔÇŁ :

 ^((?!hede).)*$
 

Eski, her konumda de─čil, yaln─▒zca giri┼č dizesinin ilk konumunda ÔÇťhedeÔÇŁ olup olmad─▒─č─▒n─▒ kontrol eder.


699







E─čer sadece grep i├žin kullan─▒yorsun, sen kullanabilirsiniz grep -v hede hede i├žermeyen t├╝m sat─▒rlar─▒ al─▒r.

ETA Soruyu tekrar okumak grep -v , muhtemelen "ara├ž se├ženekleri" ile neyi kastediyorsunuzdur.


196







Cevap:

 ^((?!hede).)*$
 

A├ž─▒klama:

^ dizenin ba┼člang─▒c─▒, ( grup ve \ 1 olarak yakala (0 veya daha fazla kez (m├╝mk├╝n olan en fazla miktarda e┼čle┼čerek)),
(?! olup olmad─▒─č─▒n─▒ g├Ârmek i├žin ileriye bak─▒n,

hede senin dize

) ileriye bakma sonunda, . \ n,
)* \ 1 d─▒┼č─▒nda herhangi bir karakter (Not: bu yakalamada nicelik kulland─▒─č─▒n─▒z i├žin, yakalanan desenin yaln─▒zca SON tekrar─▒, \ 1
$ ├Â─česinde, iste─če ba─čl─▒ bir \ n'den ├Ânce saklanacakt─▒r) , ve dizenin sonu


148







Verilen cevaplar gayet iyi, sadece akademik bir nokta:

Teorik bilgisayar bilimleri anlam─▒nda D├╝zenli ─░fadeler M├ťMK├ťN DE─×─░LD─░R bu gibi yapaca─č─▒z. Onlar i├žin ┼č├Âyle bir ┼čeye bakmak zorunda kald─▒:

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

Bu sadece tam bir e┼čle┼čme yapar. Alt e┼čle┼čmeler i├žin yapmak daha da garip olurdu.


97







Regex testinin ancak dizenin tamam─▒ e┼čle┼čirse ba┼čar─▒s─▒z olmas─▒n─▒ istiyorsan─▒z , a┼ča─č─▒dakiler i┼če yarayacakt─▒r:

 ^(?!hede$).*
 

├Ârne─čin - "foo" d─▒┼č─▒ndaki t├╝m de─čerlere izin vermek istiyorsan─▒z (yani "foofoo", "barfoo" ve "foobar" ge├žer, ancak "foo" ba┼čar─▒s─▒z olur): ^(?!foo$).*

Elbette, e─čer e┼čitli─či tam olarak kontrol ediyorsan─▒z , bu durumda daha iyi bir genel ├ž├Âz├╝m, dize e┼čitli─čini kontrol etmek, yani

 myStr !== 'foo'
 

Herhangi bir regex ├Âzelli─čine ihtiyac─▒n─▒z varsa (burada, b├╝y├╝k / k├╝├ž├╝k harf duyarl─▒l─▒─č─▒ ve aral─▒k e┼čle┼čtirmesi) olumsuzlamay─▒ testin d─▒┼č─▒na bile koyabilirsiniz :

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

Bununla birlikte, bu cevab─▒n ba┼č─▒ndaki regex ├ž├Âz├╝m├╝, olumlu bir regex testinin gerekli oldu─ču durumlarda (belki de bir API taraf─▒ndan) yard─▒mc─▒ olabilir.


55







FWIW, normal diller (yani rasyonel diller) tamamlama alt─▒nda kapat─▒ld─▒─č─▒ndan, ba┼čka bir ifadeyi olumsuz etkileyen d├╝zenli bir ifade (aka rasyonel ifade) bulmak her zaman m├╝mk├╝nd├╝r. Ancak bunu pek ├žok ara├ž uygulamamaktad─▒r.

Vcsn bu operat├Âr├╝ destekler (g├Âsterdi─či {c} , postfix).

├ľncelikle ifadelerin t├╝r├╝n├╝ tan─▒mlamak: etiketlerdir harfi ( lal_char ) almaya gelen a i├žin z ├Ârne─čin (alfabe tan─▒mlayan tamamlama ile ├žal─▒┼č─▒rken, elbette ├žok ├Ânemlidir) ve her kelime i├žin hesaplanan "de─čer" sadece bir Boole oldu─čunu : true kelime kabul edilir false , reddedilir.

Python'da:

 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} Ôćĺ ?
 

sonra ifadenizi girersiniz:

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

bu ifadeyi otomatiteye d├Ân├╝┼čt├╝r:

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


─░lgili otomat

Sonunda, bu otomat─▒ basit bir ifadeye d├Ân├╝┼čt├╝r├╝n.

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

burada + genellikle belirtilir | , \e bo┼č s├Âzc├╝─č├╝ belirtir ve [^] genellikle yaz─▒l─▒r . (herhangi bir karakter). Yani, biraz yeniden yazarak ()|h(ed?)?|([^h]|h([^e]|e([^d]|d([^e]|e.)))).* .

Bu ├Ârne─či burada g├Ârebilirsiniz ve orada ├ževrimi├ži Vcsn'i deneyin .


53







Burada , keyfi bir regex'i neden olumsuz etkilemenin kolay olmad─▒─č─▒n─▒ anlatan iyi bir a├ž─▒klama . Yine de di─čer cevaplarla ayn─▒ fikirde olmal─▒y─▒m: e─čer varsay─▒msal bir sorudan ba┼čka bir ┼čeyse, o zaman bir regex burada do─čru se├žim de─čildir.


51







Negatif bak─▒┼č a├ž─▒s─▒yla, d├╝zenli ifade ├Âzel desen i├žermeyen bir ┼čeyle e┼čle┼čebilir. Bu cevap ve Bart Kiers taraf─▒ndan a├ž─▒klanm─▒┼čt─▒r. Harika bir a├ž─▒klama!

Bununla birlikte, Bart Kiers'─▒n cevab─▒nda, g├Âz al─▒c─▒ k─▒s─▒m, herhangi bir tek karakteri e┼čle┼čtirirken ileride 1 ila 4 karakter test edecek. Bundan ka├ž─▒nabilir ve bak─▒┼č k─▒sm─▒n─▒n t├╝m metni kontrol etmesine izin veririz, 'hedef' olmad─▒─č─▒ndan emin oluruz ve sonra normal k─▒s─▒m (. *) T├╝m metni ayn─▒ anda yiyebilir.

Geli┼čtirilmi┼č regex ─░┼čte:

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

Negatif g├Âr├╝n├╝┼č k─▒sm─▒ndaki (*?) Tembel niceleyicinin iste─če ba─čl─▒ oldu─čuna dikkat edin, verilerinize ba─čl─▒ olarak (*) a├žg├Âzl├╝ niceleyiciyi kullanabilirsiniz: e─čer 'hede' varsa ve metnin ba┼člang─▒c─▒nda tembel niceleyici daha h─▒zl─▒ ol; Aksi takdirde a├žg├Âzl├╝ miktar belirleyici daha h─▒zl─▒ olur. Ancak 'hede' yoksa, ikisi de e┼čit yava┼čt─▒r.

─░┼čte demo kodu .

Lookahead hakk─▒nda daha fazla bilgi i├žin l├╝tfen harika makaleye g├Âz at─▒n : Lookahead ve Lookbehind .

Ayr─▒ca, karma┼č─▒k d├╝zenli ifadeler olu┼čturman─▒za yard─▒mc─▒ olan bir JavaScript Normal ─░fade ├ťreticisi olan RegexGen.js dosyas─▒n─▒ da kontrol edin . RegexGen.js ile regex'i daha okunakl─▒ bir ┼čekilde yap─▒land─▒rabilirsiniz:

 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()
);
 

43







Deneyler

Sunulan Se├ženeklerin baz─▒lar─▒n─▒ de─čerlendirmeye ve performanslar─▒n─▒ kar┼č─▒la┼čt─▒rmaya karar verdim, ayr─▒ca yeni ├ľzellikler kullanmaya karar verdim. .NET Regex Motorunda Kar┼č─▒la┼čt─▒rma: http://regexhero.net/tester/

Kar┼č─▒la┼čt─▒rma Metni:

─░lk 7 sat─▒r birbiriyle e┼čle┼čmemelidir, ├ž├╝nk├╝ aranan ─░fade'yi i├žerirken, alt 7 sat─▒r e┼čle┼čmelidir!

 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.
 

Sonu├žlar:

3 saniyenin ortancas─▒ olarak saniye ba┼č─▒na sonu├žlar: - B├╝y├╝k Say─▒ = Daha ─░yi

 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 eylem fiillerini desteklemedi─činden (* FAIL, vb.) P1 ve P2 ├ž├Âz├╝mlerini test edemedim.

├ľzet:

En ├žok ├Ânerilen ├ž├Âz├╝mleri test etmeye ├žal─▒┼čt─▒m, baz─▒ kelimeler i├žin baz─▒ Optimizasyonlar yap─▒labilir. ├ľrne─čin, arama dizesinin ilk iki harfi ayn─▒ de─čilse, yan─▒t 03, ^(?>[^R]+|R+(?!egex Hero))*$ k├╝├ž├╝k bir performans kazanc─▒yla sonu├žlanacak ┼čekilde geni┼čletilebilir .

Ancak, genel olarak en okunakl─▒ ve performans a├ž─▒s─▒ndan en h─▒zl─▒ ├ž├Âz├╝m, ko┼čullu bir ifade kullanarak 05 veya sahip olunan niceleyici ile 04 gibi g├Âr├╝n├╝yor. Perl ├ž├Âz├╝mlerinin daha h─▒zl─▒ ve daha kolay okunabilir olmas─▒ gerekti─čini d├╝┼č├╝n├╝yorum.


41







Regex de─čil, ancak g├╝r├╝lt├╝y├╝ engellemek i├žin seri grepleri boruyla kullanmak mant─▒kl─▒ ve yararl─▒ buldum.

├ľrne─čin. t├╝m yorumlar olmadan bir apache yap─▒land─▒rma dosyas─▒nda arama yap

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

ve

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

Seri grep'in mant─▒─č─▒ (yorum de─čil) ve (dir ile e┼čle┼čir)


32







Bununla, her pozisyonda bir bak─▒┼č a├ž─▒s─▒ test etmekten ka├ž─▒n─▒rs─▒n─▒z:

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

e┼čittir (.net i├žin):

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

Eski cevap:

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

29







Yukar─▒da bahsedilenler (?:(?!hede).)* harikad─▒r ├ž├╝nk├╝ sabitlenebilirler.

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

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

Ancak bu durumda a┼ča─č─▒dakiler yeterli olacakt─▒r:

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

Bu sadele┼čtirme, "AND" c├╝mlelerinin eklenmesine haz─▒rd─▒r:

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

20







─░┼čte nas─▒l yapar─▒m:

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

Di─čer cevaplardan daha do─čru ve daha verimli. Friedl'in "d├Âng├╝y├╝ a├žma" verimlilik tekni─čini uygular ve ├žok daha az geri izleme gerektirir.


19







Negate karakter s─▒n─▒f─▒na benzer bir kelimeyi olumsuzlamak i├žin bir karakterle e┼čle┼čtirmek istiyorsan─▒z:

├ľrne─čin, bir dize:

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

Kullanmay─▒n:

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

kullan─▒n:

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

Dikkat "(?!bbb)." , ne g├Âze ├žarp─▒yor ne de g├Âz at─▒yor, mesela ┼ču anki durumu:

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

17







Benim g├Âr├╝┼č├╝me g├Âre, en iyi cevab─▒n daha okunabilir bir ├že┼čidi:

 ^(?!.*hede)
 

Temel olarak, "sat─▒r─▒n ba┼č─▒nda sadece i├žinde 'hedef' yoksa ve sadece ├žizginin ba┼člang─▒c─▒nda e┼čle┼čtirin" - bu nedenle gereksinim neredeyse do─črudan regex'e ├ževrilir.

Tabii ki, birden fazla ba┼čar─▒s─▒zl─▒k ┼čart─▒ olmas─▒ m├╝mk├╝nd├╝r:

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

Ayr─▒nt─▒lar: ^ ankraj─▒, regex motorunun dizedeki her konumda e┼čle┼čmeyi denememesini sa─člar; bu da her dizeyle e┼čle┼čir.

^ Ba┼č─▒ndaki ├žapa, sat─▒r─▒n ba┼člang─▒c─▒n─▒ temsil etmek i├žindir. Grep arac─▒ her sat─▒ra birer birer e┼čle┼čir, ├žok sat─▒rl─▒ bir dizeyle ├žal─▒┼čt─▒─č─▒n─▒z ba─člamlarda "m" i┼čaretini kullanabilirsiniz:

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

veya

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

14







OP Tag, Regex'in i├žinde kullan─▒laca─č─▒ ba─člam─▒ (programlama dili, edit├Âr, ara├ž) belirtmek i├žin yaz─▒y─▒ belirtmedi ya da g├Ândermedi.

Benim i├žin, bazen bir dosyay─▒ kullanarak d├╝zenlerken bunu yapmak gerekir Textpad .

Textpad Baz─▒ Regex'i destekler, ancak lookahead veya lookbehind'i desteklemez, bu y├╝zden birka├ž ad─▒m al─▒r.

Ben t├╝m hatlar─▒ korumak i├žin ar─▒yorum varsa ETMEY─░N dizeyi i├žeren hede , b├Âyle yapaca─č─▒n─▒:

1. Herhangi bir metni i├žeren her sat─▒r─▒n ba┼č─▒na benzersiz bir "Etiket" eklemek i├žin t├╝m dosyay─▒ aray─▒n / de─či┼čtirin.

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

2. Dizeyi i├žeren t├╝m sat─▒rlar─▒ silin hede (de─či┼čtirme dizesi bo┼č):

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

3. Bu noktada, geri kalan t├╝m sat─▒rlar ETMEY─░N dizeyi i├žeren hede . E┼čsiz "Etiket" i t├╝m sat─▒rlardan kald─▒r─▒n (de─či┼čtirme dizesi bo┼č):

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

Art─▒k orijinal metni, dizeyi i├žeren t├╝m sat─▒rlar hede kald─▒r─▒lm─▒┼č olarak ald─▒n─▒z .


Ben ar─▒yorum E─čer ba┼čka bir ┼čey yapmak sadece hatlar─▒na Do DE─×─░L dizeyi i├žeren hede , b├Âyle yapaca─č─▒n─▒:

1. Herhangi bir metni i├žeren her sat─▒r─▒n ba┼č─▒na benzersiz bir "Etiket" eklemek i├žin t├╝m dosyay─▒ aray─▒n / de─či┼čtirin.

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

2. Dizeyi i├žeren t├╝m sat─▒rlar hede i├žin, benzersiz "Tag" i kald─▒r─▒n:

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

Bu noktada 3. benzersiz "Etiket" ile ba┼člayan t├╝m sat─▒rlar─▒, Do DE─×─░L dizeyi i├žeren hede . ┼×imdi benim yapabilece─čim Something Else sadece bu hatlara.

4. Yapt─▒─č─▒mda, benzersiz "Tag" ─▒ t├╝m sat─▒rlardan kald─▒r─▒yorum (de─či┼čtirme dizesi bo┼č):

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

13







Ruby-2.4.1ÔÇÖin kullan─▒lmas─▒ndan bu yana, yeni Absent Operat├Âr├╝n├╝ RubyÔÇÖnin Normal ─░fadelerinde kullanabiliriz.

resmi dok├╝manda

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

B├Âylece, sizin durumunuzda ^(?~hede)$ i┼č sizin i├žin yapar

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

10







PCRE fiili arac─▒l─▒─č─▒yla (*SKIP)(*F)

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

Bu, tam dize i├žeren sat─▒r─▒ tamamen atlar hede ve kalan t├╝m sat─▒rlarla e┼čle┼čir.

DEMO

Par├žalar─▒n icras─▒:

Yukar─▒daki regex'i ikiye b├Âlerek ele alal─▒m.

  1. Sembolden ├Ânceki | k─▒s─▒m. Par├ža e┼čle┼čmemeli .

     ^hede$(*SKIP)(*F)
     
  2. | Sembol├╝nden sonra bir b├Âl├╝m . Par├ža e┼čle┼čtirilmelidir .

     ^.*$
     

B├ľL├ťM 1

Regex motoru ilk par├žadan ├žal─▒┼čmaya ba┼člayacakt─▒r.

 ^hede$(*SKIP)(*F)
 

A├ž─▒klama:

  • ^ Ba┼čta oldu─čumuzu iddia ediyor.
  • hede Dizeyle e┼čle┼čir hede
  • $ Sat─▒r sonunda oldu─čumuzu iddia ediyor.

B├Âylece dizeyi i├žeren ├žizgi hede e┼čle┼čir. Regex motoru ┼ču g├Ârd├╝kten sonra (*SKIP)(*F) ( : Not Sen yazabilirsiniz (*F) olarak (*FAIL) fiil, bu atlar) ve e┼čleme ba┼čar─▒s─▒z olun. | PCRE fiilinin yan─▒na eklenen de─či┼čiklik veya mant─▒ksal OR operat├Âr├╝ olarak adland─▒r─▒lan ve ba┼člang─▒├ž ÔÇőÔÇős─▒n─▒rlar─▒n─▒ tam olarak e┼čle┼čtiren t├╝m sat─▒rlar aras─▒nda var olan t├╝m sat─▒rlar aras─▒ndaki ├žizgi hari├ž sat─▒rlar─▒n tamam─▒ tam dizedir hede . Demoyu burada g├Ârebilirsiniz . Yani, kalan dizgeden gelen karakterleri e┼čle┼čtirmeye ├žal─▒┼č─▒r. ┼×imdi ikinci b├Âl├╝mdeki regex ├žal─▒┼čt─▒r─▒lacakt─▒.

B├ľL├ťM 2

 ^.*$
 

A├ž─▒klama:

  • ^ Ba┼čta oldu─čumuzu iddia ediyor. yani, sat─▒rdakiler hari├ž t├╝m sat─▒r ba┼člang─▒c─▒yla e┼čle┼čir hede . Demoyu burada g├Ârebilirsiniz .
  • .* ├çok sat─▒rl─▒ modda, . yeni sat─▒r veya sat─▒r ba┼č─▒ karakterleri d─▒┼č─▒ndaki herhangi bir karakterle e┼čle┼čir. Ve * ├Ânceki karakteri s─▒f─▒r veya daha fazla kez tekrarlard─▒. B├Âylece .* t├╝m ├žizgi e┼čle┼čecek. Demoyu burada g├Ârebilirsiniz .

    Hey neden eklediniz. * Yerine?

    ├ç├╝nk├╝ .* bo┼č bir sat─▒rla e┼čle┼čir, ancak .+ bo┼č bir e┼čle┼čmez. Bunun d─▒┼č─▒nda t├╝m sat─▒rlar─▒ e┼čle┼čtirmek istiyoruz hede , giri┼čte de bo┼č sat─▒rlar olabilir. bu y├╝zden .* yerine kullanman─▒z gerekir .+ . .+ ├Ânceki karakteri bir veya daha fazla kez tekrarlard─▒. Burada .* bo┼č bir sat─▒rla e┼čle┼čmeye bak─▒n .http://regex101.com/r/kR0tO2/5

  • $ Burada ├žapan─▒n sonu ba─člant─▒s─▒ gerekli de─čildir.


9







Ba┼čka hi├ž kimse sorulan soruya do─črudan bir cevap vermedi─činden, ben yapaca─č─▒m.

Cevap, POSIXÔÇÖde grep , bu talebi tam anlam─▒yla yerine getirmenin m├╝mk├╝n olmamas─▒d─▒r:

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

Bunun nedeni, POSIX'in grep yaln─▒zca bu g├Ârevin yerine getirilmesi i├žin yeterince g├╝├žl├╝ olmayan Basit (Normal D├╝zenli ─░fadeler) ile ├žal─▒┼čmas─▒ i├žin gerekli olmas─▒d─▒r (de─či┼čim ve parantez eksikli─či nedeniyle normal dilleri ayr─▒┼čt─▒ramazlar).

Ancak, GNU grep buna izin veren uzant─▒lar─▒ uygular. ├ľzellikle, \| BRES ait GNU uygulanmas─▒nda m├╝navebe operat├Âr├╝d├╝r ve \( ve \) parantez vard─▒r. D├╝zenli ifade motorunuz de─či┼čmeyi, negatif parantez ifadelerini, parantezleri ve Kleene y─▒ld─▒z─▒n─▒ destekliyorsa ve dizenin ba┼č─▒na ve sonuna tutturulabilirse, bu yakla┼č─▒m i├žin ihtiyac─▒n─▒z olan tek ┼čey budur. Bununla birlikte, negatif k├╝melerin [^ ... ] bunlara ek olarak ├žok uygun oldu─čunu unutmay─▒n ; aksi takdirde, bunlar─▒ (a|b|c| ... ) k├╝mede bulunmayan her karakteri listeleyen, a┼č─▒r─▒ derecede s─▒k─▒c─▒ ve a┼č─▒r─▒ uzun, hatta daha uzun s├╝ren bir ifadeyle de─či┼čtirmeniz gerekir. T├╝m karakter k├╝mesi Unicode'dur.

GNU ile grep cevap ┼č├Âyle bir ┼čey olurdu:

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

( Grail ve elle yap─▒lan baz─▒ optimizasyonlar ile bulunur).

Ayr─▒ca uygular bir arac─▒ kullanabilirsiniz Normal ─░fadeleri Extended gibi egrep ters e─čik kurtulmak i├žin,:

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

─░┼čte test etmek i├žin bir komut dosyas─▒ ( testinput.txt ge├žerli dizinde bir dosya olu┼čturdu─čunu unutmay─▒n ):

 #!/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)
 

Sistemimde yazd─▒r─▒r:

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

beklenildi─či gibi.

Ayr─▒nt─▒larla ilgilenenler i├žin, kullan─▒lan teknik, kelimeyi e┼čle┼čen normal ifadeyi sonlu bir otomati─če d├Ân├╝┼čt├╝rmek, daha sonra her kabul durumunu kabul etmemek ve tam tersi olarak de─či┼čtirmek ve sonu├žta ortaya ├ž─▒kan FA'yi geri d├Ân├╝┼čt├╝rmek i├žin otomati─či tersine ├ževirmektir. d├╝zenli bir ifade.

Son olarak, herkesin belirtti─či gibi, d├╝zenli ifade motorunuz negatif g├Âr├╝n├╝┼č├╝ destekliyorsa, bu g├Ârevi ├žok kolayla┼čt─▒r─▒r. ├ľrne─čin, GNU grep ile:

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

G├╝ncelleme: Ge├ženlerde Kendall HopkinsÔÇÖin GrailÔÇÖe benzer bir i┼člevsellik sa─člayan PHPÔÇÖde yaz─▒lm─▒┼č m├╝kemmel FormalTheory k├╝t├╝phanesini buldum . Kullanarak ve kendim taraf─▒ndan yaz─▒lm─▒┼č bir basitle┼čtirici kullanarak, giri┼č ifadesi verilen (├ževrimi├ži olarak yaln─▒zca alfasay─▒sal ve bo┼čluk karakterleri destekli) negatif d├╝zenli ifadelerin ├ževrimi├ži olu┼čturucusunu yazabildim: http://www.formauri.es/personal/ pgimeno / misc / olmayan ma├ž-regex /

─░├žin hede o ├ž─▒kar─▒r:

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

Yukar─▒dakilere e┼čde─čerdir.


9







Kodunuzda, biri ilk e┼čle┼čmeyi yapmak i├žin iki regex'e daha uygun olabilir ve daha sonra e┼čle┼čirse, ├Ârne─čin engellemek istedi─činiz genel durumlar─▒ kontrol etmek i├žin ikinci regex'i ├žal─▒┼čt─▒r─▒rsan─▒z, ├Ârne─čin ^.*(hede).* kodunuzda uygun bir mant─▒─ča sahip olabilirsiniz.

Tamam, bunun iletilen soruya bir cevap olmad─▒─č─▒n─▒ kabul ediyorum ve ayn─▒ zamanda tek bir regex'ten biraz daha fazla i┼člem gerektirebilir. Ancak buraya genel bir durum i├žin h─▒zl─▒ bir acil durum d├╝zeltmesi i├žin gelen geli┼čtiriciler i├žin o zaman bu ├ž├Âz├╝m g├Âzden ka├ž─▒r─▒lmamal─▒d─▒r.


7







TXR Dil regex yads─▒mas─▒n─▒ destekler.

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

Daha karma┼č─▒k bir ├Ârnek: ile ba┼člayan a ve sonlanan z , ancak alt dizeyi i├žermeyen t├╝m sat─▒rlar─▒ e┼čle┼čtirin 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 olumsuzlamas─▒ ├Âzellikle kendi ba┼č─▒na yararl─▒ de─čildir, ancak ayn─▒ zamanda bir kesi┼čim oldu─čunda, i┼čler ilgin├ž hale gelir, ├ž├╝nk├╝ tam bir boolik k├╝me i┼člemi k├╝mesi vard─▒r: "buna uyan k├╝meler hari├ž" ifadesini "e┼čle┼čtirebilirsiniz" ifadesini kullanabilirsiniz.


5







A┼ča─č─▒daki i┼člev istedi─činiz ├ž─▒kt─▒y─▒ alman─▒za yard─▒mc─▒ olacakt─▒r

 <?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;
    }


?>
 

4







^ ((?! hede).) * $ zarif bir ├ž├Âz├╝md├╝r, ├ž├╝nk├╝ karakterleri kullanmas─▒ d─▒┼č─▒nda onu di─čer kriterler ile birle┼čtiremezsiniz. ├ľrne─čin, "hede" nin bulunmad─▒─č─▒n─▒ ve "haha" n─▒n varl─▒─č─▒n─▒ kontrol etmek istedi─činizi varsayal─▒m. Bu ├ž├Âz├╝m i┼če yarayacak ├ž├╝nk├╝ karakter t├╝ketmeyecek:

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


2







PCRE'nin geri izleme kontrol fiilleri, kelime i├žermeyen bir ├žizgiyle e┼čle┼čmek i├žin nas─▒l kullan─▒l─▒r?

─░┼čte daha ├Ânce hi├ž g├Ârmedi─čim bir y├Ântem:

 /.*hede(*COMMIT)^|/
 

Nas─▒l ├žal─▒┼č─▒r

─░lk ├Ânce, ├žizgiyi bir yere "hede" bulmaya ├žal─▒┼č─▒r. Ba┼čar─▒l─▒ olursa, bu noktada, (*COMMIT) motora yaln─▒zca bir ar─▒za durumunda geri izlemeyi de─čil, ayn─▒ zamanda bu durumda ba┼čka bir e┼čle┼čme denemesini de s├Âylemedi─čini s├Âyler. Ard─▒ndan, e┼čle┼čemeyecek bir ┼čeyi e┼čle┼čtirmeye ├žal─▒┼č─▒r─▒z (bu durumda ^ ).

Bir sat─▒r "hede" i├žermiyorsa, ikinci alternatif olan bo┼č bir alt ┼čablon, konu dizgisine ba┼čar─▒yla e┼čle┼čir.

Bu y├Ântem, olumsuz bir bak─▒┼čtan daha etkili de─čildir, ancak birinin ┼č─▒k bulmas─▒ ve ba┼čka, daha ilgin├ž uygulamalar i├žin bir kullan─▒m bulmas─▒ durumunda, onu buraya ataca─č─▒m─▒ d├╝┼č├╝nd├╝m.


1







Do bir hat (ayn─▒ t├╝m hatlar─▒ kar┼č─▒) segmentlerini ma├ž yapabiliyor bir regex yaz─▒lmaya ├žal─▒┼č─▒l─▒rken Belki Google'da bu bulacaks─▒n─▒z de─čil bir alt i├žerir. Anlamak i├žin bir s├╝re beni konu┼čtu, ben de payla┼čaca─č─▒m:

Bir dize verilen: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

<span> "Bad" alt dizesini i├žermeyen etiketleri e┼čle┼čtirmek istiyorum .

/<span(?:(?!bad).)*?> <span class=\"good\"> ve e┼čle┼čecek <span class=\"ugly\"> .

─░ki set parantez oldu─čuna dikkat edin:

  • En i├žteki olan─▒ negatif bak─▒┼č a├ž─▒s─▒ i├žindir (bir ele ge├žirme grubu de─čildir)
  • En d─▒┼č k─▒s─▒m Ruby taraf─▒ndan yakalama grubu olarak yorumland─▒, ancak yakalama grubu olmas─▒n─▒ istemiyoruz, bu y├╝zden ekledim mi? Ba┼č─▒nda ve art─▒k bir yakalama grubu olarak yorumlanm─▒yor.

Ruby'de Demo:

 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\">"]
 

1







Di─čer bir se├ženek ise, olumlu bir g├Âr├╝n├╝m eklemek hehe ve giri┼č sat─▒r─▒nda herhangi bir yer olup olmad─▒─č─▒n─▒ kontrol etmektir. ├ľyleyse, a┼ča─č─▒dakini benzer bir ifadeyle reddederiz:

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

kelime s─▒n─▒rlar─▒ ile.


─░fade regex101.com'un sa─č ├╝st panelinde a├ž─▒klanmakta, ara┼čt─▒rmak / basitle┼čtirmek / de─či┼čtirmek istiyorsan─▒z bu linkte isterseniz baz─▒ ├Ârnek giri┼čleriyle nas─▒l e┼čle┼čece─čini izleyebilirsiniz.


RegEx Devresi

jex.im d├╝zenli ifadeleri g├Ârselle┼čtirir:


g├Âr├╝nt├╝ tan─▒m─▒n─▒ buraya girin


1







Operat├Âr kullanmamak daha basit bir ├ž├Âz├╝md├╝r !

Sizin e─čer deyim kar┼č─▒lamalar─▒ gerekti─čini ve "Kapsam d─▒┼č─▒" e┼čle┼čmiyor "i├žerir".

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

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

RegEx tasar─▒mc─▒lar─▒n─▒n operat├Âr de─čil kullan─▒m─▒n─▒ ├Âng├Ârd├╝─č├╝n├╝ d├╝┼č├╝n├╝yorum.


0







─░le ConyEdit , komut sat─▒r─▒n─▒ kullanabilirsiniz cc.gl !/hede/ Normal ifade e┼člemeyi i├žeren veya komut sat─▒r─▒n─▒ kullanmayan sat─▒rlar─▒ almak i├žin cc.dl /hede/ Normal ifade e┼člemeyi ihtiva silme hatlar─▒na. Ayn─▒ sonu├ž var.


0



─░lgili yay─▒nlar


DNS ana bilgisayar ad─▒ veya IP adresiyle e┼čle┼čtirmek i├žin normal ifade mi?

Bir URL ile e┼čle┼čecek iyi bir normal ifade nedir? [├žift]

Dengeli parantezleri e┼čle┼čtirmek i├žin normal ifade

ASCII olmayan karakterlerle e┼čle┼čmesi i├žin normal ifade mi?

Yaln─▒zca alfabetik karakterlerle e┼čle┼čmesi i├žin Normal ─░fade

Bir s├Âzc├╝─č├╝ veya ├Ânekini e┼čle┼čtirmek i├žin normal ifade

Standart 10 haneli telefon numaras─▒na uymas─▒ i├žin normal ifade

10 defadan fazla tekrarlanan karakterlerle e┼čle┼čmesi i├žin d├╝zenli ifade

Rakamlarla virg├╝l veya virg├╝l olmadan ve metindeki ondal─▒k say─▒lar─▒ e┼čle┼čtirmek i├žin normal ifade

"Dur" ile ba┼člayan dizgiyi e┼čle┼čtirmek i├žin Normal ─░fade

Etiketle ilgili di─čer sorular [regex]


ArrayList'in bir sat─▒rda ba┼člat─▒lmas─▒

Nesneleri HTML5 localStorage uygulamas─▒nda saklama

Kabukta ÔÇť2> & 1ÔÇŁ ne anlama geliyor?

HTML'deki id niteli─či i├žin ge├žerli de─čerler nelerdir?

Linux'ta bir dosyay─▒ nas─▒l ba─člayabilirim? [kapal─▒]

JavaScript String'i k├╝├ž├╝k harf olarak d├Ân├╝┼čt├╝rmek ister misiniz?

C'deki fonksiyon i┼čaret├žileri nas─▒l ├žal─▒┼č─▒r?

Python 3 e┼čde─čeri ÔÇťpython -m SimpleHTTPServerÔÇŁ

Node.js dosyas─▒n─▒ basit bir web sunucusu olarak kullanmak

Div'de kesinlikle konumland─▒r─▒lm─▒┼č eleman nas─▒l ortalan─▒r?