වචනයක් ගැළපීමටත් පසුව වෙනත් මෙවලම් භාවිතයෙන් තරඟ ආපසු හැරවීමටත් හැකි බව මම දනිමි (උදා grep -v). කෙසේ වෙතත්, නිශ්චිත වචනයක් අඩංගු නොවන රේඛා hedeගැලපීමට හැකිද , උදා , සාමාන්‍ය ප්‍රකාශනයක් භාවිතා කරමින්?

ආදානය:

hoho
hihi
haha
hede

කේතය:

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

අපේක්ෂිත ප්‍රතිදානය:

hoho
hihi
haha

ප්‍රතිලෝම ගැලපීමට රීජෙක්ස් සහාය නොදක්වයි යන මතය මුළුමනින්ම සත්‍ය නොවේ. Negative ණාත්මක පෙනුමක් භාවිතා කිරීමෙන් ඔබට මෙම හැසිරීම අනුකරණය කළ හැකිය:

^((?!hede).)*$

ඉහත රීජෙක්ස් (උප) නූල 'හෙඩ්' අඩංගු නොවන රේඛා බිඳීමකින් තොරව ඕනෑම නූලකට හෝ රේඛාවකට ගැලපේ. ඉහත සඳහන් කළ පරිදි, මේ දෙයක් regex දී "හොඳ" වේ (හෝ කළ යුත්තේ) නොවේ, නමුත් තවමත්, එය වේ හැකි.

ඔබට පේළි කඩන අක්ෂර ගැලපීමට අවශ්‍ය නම්, DOT-ALL විකරණකාරකය භාවිතා කරන්න ( sපහත රටාවේ පසුපසින් ):

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

හෝ එය පේළියේ භාවිතා කරන්න:

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

(මෙහි දී /.../රීජෙක්ස් පරිසීමකය, එනම් රටාවේ කොටසක් නොවේ)

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හිස් නූල් වේ. රීජෙක්ස් (?!hede).ඉදිරිය දෙස බලන්නේ උපස්ථරයක් දැකිය නොහැකි දැයි බැලීමට නම් "hede", එය එසේ නම් (වෙනත් දෙයක් දැකිය හැක), එවිට .(තිත) රේඛා බිඳීමක් හැර වෙනත් ඕනෑම චරිතයකට ගැලපේ. කිසිදු අක්ෂර පරිභෝජනය නොකරන නිසා බැලූ බැල්මට ශුන්‍ය පළල-ප්‍රකාශයන් ලෙසද හැඳින්වේ . ඔවුන් යමක් තහවුරු කිරීම / වලංගු කිරීම පමණි.

එබැවින්, මගේ උදාහරණයේ දී, සෑම හිස් නූලක්ම මුලින්ම වලංගු වන්නේ "hede"ඉදිරියෙන් නැද්ද යන්න බැලීමට ය .. රීජෙක්ස් (?!hede).එය සිදු කරන්නේ එක් වරක් පමණි, එබැවින් එය කණ්ඩායමකට ඔතා, නැවත නැවත ශුන්‍ය හෝ වැඩි වාර ගණනක් : ((?!hede).)*. අවසාන වශයෙන්, සම්පූර්ණ ආදානය පරිභෝජනය කරන බවට වග බලා ගැනීම සඳහා ආරම්භක හා අවසාන ආදානය නැංගුරම් ලා ඇත:^((?!hede).)*$

ඔබ දැක ගැනීමට හැකි වන පරිදි, ආදාන "ABhedeCD"නිසා මත අසාර්ථක වනු ඇත e3, මේ regex (?!hede)(එහි අසමත් වේ "hede" ඉදිරියට දක්වා!).

විසඳුම “හෙඩ්” වලින් ආරම්භ නොවන බව සලකන්න :

^(?!hede).*$

“හෙඩ්” අඩංගු නොවන විසඳුමට වඩා සාමාන්‍යයෙන් වඩා කාර්යක්ෂම වේ :

^((?!hede).)*$

කලින් “හෙඩ්” සඳහා පරික්ෂා කරන්නේ සෑම ස්ථානයකටම වඩා ආදාන නූලෙහි පළමු ස්ථානයේ පමණි.

ඔබ එය grep සඳහා භාවිතා කරන්නේ නම්, ඔබට grep -v hedeහෙඩ් අඩංගු නොවන සියලුම රේඛා ලබා ගත හැකිය .

ETA ඔහ්, ප්‍රශ්නය නැවත කියවීම, grep -vබොහෝ විට ඔබ අදහස් කළේ "මෙවලම් විකල්ප" යන්නයි.

පිළිතුර:

^((?!hede).)*$

පැහැදිලි කිරීම:

^නූලේ ආරම්භය, (සමූහය සහ ග්‍රහණය \ 1 (0 හෝ ඊට වැඩි වාර ගණනක් (හැකි උපරිම ප්‍රමාණයට ගැලපේ)),
(?!නොමැතිදැයි බැලීමට බලා සිටින්න,

hede ඔබේ නූල,

)ඉදිරියෙන් බැලීමේ අවසානය, .character n හැර ඕනෑම අක්ෂරයක්,
)*\ 1 හි අවසානය (සටහන: ඔබ මෙම ග්‍රහණය සඳහා ප්‍රමාණාත්මකකරණයක් භාවිතා කරන හෙයින්, අල්ලා ගත් රටාවේ අවසාන පුනරාවර්තනය පමණක් \ 1 තුළ ගබඩා වේ)
$විකල්ප \ n ට පෙර, සහ නූල් අවසානය

ලබා දී ඇති පිළිතුරු පරිපූර්ණ ය, ශාස්ත්‍රීය කරුණක් පමණි:

සිද්ධාන්තමය පරිගණක විද්යාව පිළිබඳ අර්ථය තුළ සාමාන්ය ප්රකාශිත නොහැකි මේ වගේ ඒක කරන්න. ඔවුන්ට එය මේ වගේ දෙයක් විය යුතුයි:

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

මෙය සම්පුර්ණ ගැලපීමක් පමණි. උප තරඟ සඳහා එය කිරීම ඊටත් වඩා අමුතු වනු ඇත.

ඔබ වෙත regex ටෙස්ට් අවශ්ය නම් පමණක් නම්, අසමත් සමස්ත string තරග, පහත සඳහන් වැඩ කරනු ඇත:

^(?!hede$).*

උදා - ඔබට "foo" (එනම් "foofoo", "barfoo", සහ "foobar" හැර අනෙකුත් සියලු අගයන්ට ඉඩ දීමට අවශ්‍ය නම්, නමුත් "foo" අසමත් වනු ඇත), භාවිතා කරන්න: ^(?!foo$).*

ඇත්ත වශයෙන්ම, ඔබ නිශ්චිත සමානාත්මතාවය සඳහා පරික්ෂා කරන්නේ නම්, මෙම අවස්ථාවේ දී වඩා හොඳ පොදු විසඳුමක් වන්නේ නූල් සමානාත්මතාවය පරීක්ෂා කිරීමයි, එනම්

myStr !== 'foo'

ඔබට කිසියම් රීජෙක්ස් අංගයක් අවශ්‍ය නම් ඔබට ප්‍රතික්ෂේප කිරීම පරීක්ෂණයෙන් පිටත තැබිය හැකිය (මෙහි, සිද්ධි සංවේදීතාව සහ පරාසය ගැලපීම):

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

කෙසේ වෙතත්, ධනාත්මක රීජෙක්ස් පරීක්ෂණයක් අවශ්‍ය අවස්ථාවන්හිදී (සමහර විට ඒපීඅයි මගින්) මෙම පිළිතුරේ ඉහළින් ඇති රීජෙක්ස් විසඳුම ප්‍රයෝජනවත් විය හැකිය.

FWIW, නිත්‍ය භාෂා (තාර්කික භාෂා) සම්පුර්ණ කිරීම යටතේ වසා ඇති හෙයින්, සෑම විටම වෙනත් ප්‍රකාශනයක් ප්‍රතික්ෂේප කරන නිත්‍ය ප්‍රකාශනයක් (තාර්කික ප්‍රකාශනයක්) සොයාගත හැකිය. නමුත් බොහෝ මෙවලම් මෙය ක්‍රියාත්මක නොකරයි.

Vcsn මෙම ක්‍රියාකරුට සහය දක්වයි (එය ඇඟවුම් කරන්නේ {c}, පෝස්ට්ෆික්ස්).

ලේබල් ලිපිය වේ (: ප්රථමයෙන් ඔබේ ප්රකාශන වර්ගය අර්ථ lal_charසිට එසවීමට) aවෙත z(අනුපූරණයක් සමඟ වැඩ කරන විට හෝඩියේ නිර්වචනය ඉතා වැදගත් නෙවෙයි,) උදාහරණයක් වශයෙන්, එක් එක් වචනය සඳහා ගණනය කර "අගය" පමණක් බූලීය වේ : trueවචනය පිළිගනු ලැබේ false, ප්‍රතික්ෂේප කරනු ලැබේ.

පයිතන්හි:

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 උත්සාහ එහි .

අත්තනෝමතික රීජෙක්ස් ප්‍රතික්ෂේප කිරීම පහසු නොවන්නේ මන්ද යන්න පිළිබඳ හොඳ පැහැදිලි කිරීමක් මෙන්න . අනෙක් පිළිතුරු සමඟ මට එකඟ විය යුතුය: මෙය උපකල්පිත ප්‍රශ්නයක් හැර වෙනත් දෙයක් නම්, රීජෙක්ස් මෙහි නිවැරදි තේරීම නොවේ.

නිෂේධාත්මක පෙනුමකින්, නිත්‍ය ප්‍රකාශනයට නිශ්චිත රටාවක් අඩංගු නොවන දෙයකට ගැලපේ. මෙයට පිළිතුරු සපයන්නේ බාට් කයර්ස් විසිනි. නියම පැහැදිලි කිරීමක්!

කෙසේ වෙතත්, බාර්ට් කයර්ස්ගේ පිළිතුර සමඟ, ඕනෑම තනි අක්ෂරයකට ගැලපෙන අතර පෙනුම කොටස 1 සිට 4 දක්වා ඉදිරියෙන් පරීක්ෂා කරනු ඇත. අපට මෙය වළක්වා ගත හැකි අතර, බැලූ බැල්මට සම්පූර්ණ පා text ය පරීක්ෂා කර බැලීමට ඉඩ දෙන්න, 'හෙඩ්' නොමැති බව සහතික කරන්න, ඉන්පසු සාමාන්‍ය කොටසට (. *) මුළු පා text යම එකවර ආහාරයට ගත හැකිය.

වැඩිදියුණු කළ රීජෙක්ස් මෙන්න:

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

* ණාත්මක පෙනුමේ කොටසෙහි (*?) කම්මැලි ප්‍රමාණාත්මකකරණය අත්‍යවශ්‍ය නොවන බව සලකන්න, ඔබේ දත්ත මත පදනම්ව ඔබට ඒ වෙනුවට කෑදර ප්‍රමාණාත්මකකරණය භාවිතා කළ හැකිය: 'හෙඩ්' තිබේ නම් සහ පා of යේ ආරම්භක භාගයේදී කම්මැලි ප්‍රමාණාත්මකකරණය කළ හැකිය. වේගවත් වන්න; නැතිනම් කෑදර ප්‍රමාණාත්මකය වේගවත් වේ. කෙසේ වෙතත්, 'හෙඩ්' නොපවතී නම්, දෙකම සමාන මන්දගාමී වනු ඇත.

මෙන්න ආදර්ශන කේතය .

බැල්ම හෙඩ් පිළිබඳ වැඩි විස්තර සඳහා කරුණාකර විශිෂ්ට ලිපිය බලන්න: මාස්ටර් ලුක්හෙඩ් සහ ලුක්බයින්ඩ් .

එසේම, සංකීර්ණ නිත්‍ය ප්‍රකාශන තැනීමට උපකාරී වන ජාවාස්ක්‍රිප්ට් නිත්‍ය ප්‍රකාශන උත්පාදක යන්ත්රය වන RegexGen.js බලන්න . RegexGen.js සමඟ, ඔබට වඩාත් කියවිය හැකි ආකාරයකින් රීජෙක්ස් සෑදිය හැකිය:

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 එන්ජිම මත මිණුම් සලකුණු කිරීම: 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.

ප්රතිපල:

ප්‍රති Results ල යනු තත්පරයට ලකුණු 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 ක් ලෙස පෙනේ. මම හිතන්නේ පර්ල් විසඳුම් ඊටත් වඩා වේගවත් හා පහසුවෙන් කියවිය හැකි විය යුතුයි.

රීජෙක්ස් නොවේ, නමුත් ශබ්දය තුරන් කිරීම සඳහා පයිප්ප සමඟ අනුක්‍රමික ග්‍රෙප් භාවිතා කිරීම තර්කානුකූල හා ප්‍රයෝජනවත් බව මට පෙනී ගියේය.

උදා. සියලු අදහස් දැක්වීමකින් තොරව අපාචේ වින්‍යාස ගොනුවක් සොයන්න-

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)

මේ සමඟ, ඔබ එක් එක් තනතුරු දෙස බැලීමක් වළක්වා ගනී:

/^(?:[^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

මෙම සරල කිරීම "සහ" වගන්ති එකතු කිරීමට සූදානම්:

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

මෙන්න මම එය කරන්නේ කෙසේද:

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

අනෙක් පිළිතුරු වලට වඩා නිරවද්‍ය හා කාර්යක්ෂම වේ. එය ෆ්‍රීඩ්ල්ගේ “unroll-the-loop” කාර්යක්ෂමතා තාක්‍ෂණය ක්‍රියාත්මක කරන අතර ඊට වඩා අඩු පසුබැසීමක් අවශ්‍ය වේ.

අක්‍ෂර පන්තිය නිෂේධනය කිරීමට සමාන වචනයක් නිෂේධනය කිරීමට ඔබට චරිතයක් ගැලපීමට අවශ්‍ය නම්:

උදාහරණයක් ලෙස, නූලක්:

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

පාවිච්චි කරන්න එපා:

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

භාවිත:

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

දැන්වීම "(?!bbb)."බැලූ බැල්මට හෝ බැලූ බැල්මට නොවේ, එය පෙනුමෙන් යුක්තය, උදාහරණයක් ලෙස:

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

මගේ මතය අනුව, ඉහළ පිළිතුරේ වඩා කියවිය හැකි ප්‍රභේදයකි:

^(?!.*hede)

මූලික වශයෙන්, "පේළියේ ආරම්භයේ දී 'හෙඩ්' නොමැති නම් පමණක් ගැලපෙන්න" - එබැවින් අවශ්‍යතාවය සෘජුවම පාහේ රීජෙක්ස් බවට පරිවර්තනය වේ.

ඇත්ත වශයෙන්ම, බහු අසාර්ථක අවශ්‍යතා තිබිය හැකිය:

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

විස්තර: ^ නැංගුරම මඟින් රීජෙක්ස් එන්ජිම සෑම නූලකටම ගැලපෙන නූලෙහි සෑම ස්ථානයකම තරගය නැවත උත්සාහ නොකරන බව සහතික කරයි.

ආරම්භයේ ඇති නැංගුරම යනු රේඛාවේ ආරම්භය නිරූපණය කිරීමයි. Grep මෙවලම එක් එක් පේළියට එකවර ගැලපේ, ඔබ බහු රේඛාවක් සමඟ වැඩ කරන සන්දර්භය තුළ, ඔබට "m" ධජය භාවිතා කළ හැකිය:

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

හෝ

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

Tagසන්දර්භය (ක්‍රමලේඛන භාෂාව, සංස්කාරක, මෙවලම) දැක්වීමට OP විසින් නිශ්චිතව දක්වා නොමැති අතර රෙජෙක්ස් භාවිතා කරනු ඇත.

මට නම්, සමහර විට ගොනුවක් සංස්කරණය කරමින් මෙය කිරීමට අවශ්‍ය වේ Textpad.

Textpad සමහර රීජෙක්ස් සඳහා සහය දක්වයි, නමුත් බැලූ බැල්මට හෝ බැල්ම පිටුපසින් සහාය නොදක්වයි, එබැවින් පියවර කිහිපයක් ගතවේ.

නූල් අඩංගු නොවන සියලුම රේඛා රඳවා ගැනීමට 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  

වෙන කිසිවෙකු ප්රශ්නයට සෘජු පිළිතුරක් ලබා දී ඇති නිසා ඉල්ලූ බව , මම ඒක කරන්නම්.

පිළිතුර නම්, පොසික්ස් සමඟ grep, මෙම ඉල්ලීම වචනාර්ථයෙන් සපුරාලිය නොහැකි ය:

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

හේතුව, POSIX grepඅවශ්‍ය වන්නේ මූලික නිත්‍ය ප්‍රකාශන සමඟ වැඩ කිරීම සඳහා වන අතර, එම කාර්යය ඉටු කිරීම සඳහා ප්‍රමාණවත් තරම් බලවත් නොවේ (ඒවා සාමාන්‍ය භාෂාවන් විග්‍රහ කිරීමට හැකියාවක් නැත, විකල්පයක් නොමැති අතර වරහන් වර්‍ග නොමැති නිසා).

කෙසේ වෙතත් , GNU grepඑයට ඉඩ දෙන දිගු ක්‍රියාත්මක කරයි. විශේෂයෙන් ම, \|BREs ක GNU ගේ ක්රියාත්මක කිරීම තුළ මලනවහ ක්රියාකරු වන අතර, \(සහ \)වරහන් වේ. ඔබේ නිත්‍ය ප්‍රකාශන එන්ජිම ප්‍රත්‍යාවර්ත, negative ණ වරහන් ප්‍රකාශන, වරහන් සහ ක්ලීන් තාරකාවට සහය දක්වන්නේ නම් සහ නූලෙහි ආරම්භයට හා අවසානයට නැංගුරම් දැමිය හැකි නම්, මෙම ප්‍රවේශය සඳහා ඔබට අවශ්‍ය වන්නේ එපමණකි. කෙසේ වෙතත් ඒවාට අමතරව negative ණාත්මක කට්ටල [^ ... ]ඉතා පහසු බව සලකන්න , එසේ නොමැති නම්, ඔබ ඒවා (a|b|c| ... )කට්ටලයේ නොමැති සෑම අක්ෂරයක්ම ලැයිස්තුගත කරන ආකෘතියේ ප්‍රකාශනයක් මගින් ප්‍රතිස්ථාපනය කළ යුතු අතර එය අතිශයින් වෙහෙසකර හා ඕනෑවට වඩා දිගු වන අතර ඊටත් වඩා එසේ නම් සම්පූර්ණ අක්ෂර කට්ටලය යුනිකෝඩ් වේ.

විධිමත් භාෂා න්‍යායට ස්තූතිවන්ත වන අතර, එවැනි ප්‍රකාශනයක් පෙනෙන්නේ කෙසේදැයි අපට දැකගත හැකිය. GNU සමඟ grep, පිළිතුර පහත පරිදි වේ:

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

( ග්‍රේල් සමඟ හමු වූ අතර අතින් සාදන ලද තවත් ප්‍රශස්තිකරණ කිහිපයක්).

බැක්ස්ලෑෂ් ඉවත් කිරීම වැනි දීර් Regular නිත්‍ය ප්‍රකාශන ක්‍රියාත්මක කරන මෙවලමක් ද ඔබට භාවිතා කළ හැකිය 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

බලාපොරොත්තු වූ පරිදි.

විස්තර ගැන උනන්දුවක් දක්වන අය සඳහා, භාවිතා කරන තාක්‍ෂණය නම්, වචනයට ගැළපෙන නිත්‍ය ප්‍රකාශනය සීමිත ස්වයංක්‍රීය යන්ත්‍රයක් බවට පරිවර්තනය කිරීම, ඉන්පසු සෑම පිළිගැනීමේ තත්වයක්ම පිළිගැනීමට ලක් නොවන ලෙස වෙනස් කිරීමෙන් ස්වයංක්‍රීය යන්ත්‍රය හරවා යැවීම සහ පසුව ලැබෙන FA නැවත පරිවර්තනය කිරීම ය. නිත්‍ය ප්‍රකාශනයකි.

සෑම කෙනෙකුම සටහන් කර ඇති පරිදි, ඔබේ නිත්‍ය ප්‍රකාශන එන්ජිම negative ණාත්මක පෙනුමක් සඳහා සහය දක්වන්නේ නම්, සාමාන්‍ය ප්‍රකාශනය වඩා සරල ය. උදාහරණයක් ලෙස, GNU grep සමඟ:

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

කෙසේ වෙතත්, මෙම ප්‍රවේශයට අවාසියක් ඇත, එයට පසුගාමී නිත්‍ය ප්‍රකාශන එන්ජිමක් අවශ්‍ය වේ. මෙය RE2 වැනි ආරක්ෂිත නිත්‍ය ප්‍රකාශන එන්ජින් භාවිතා කරන ස්ථාපනයන්හි නුසුදුසු බවට පත් කරයි, මෙය සමහර තත්වයන් තුළ ජනනය කළ ප්‍රවේශයට වැඩි කැමැත්තක් දැක්වීමට එක් හේතුවකි.

පීඑච්පී හි ලියා ඇති කෙන්ඩල් හොප්කින්ස්ගේ විශිෂ්ට ෆෝමල් තියරි පුස්තකාලය, ග්‍රේල්ට සමාන ක්‍රියාකාරීත්වයක් සපයන අතර, මා විසින්ම ලියන ලද සරලකාරකයක් භාවිතා කරමින් , ආදාන වාක්‍ය ඛණ්ඩයක් ලබා දී ඇති negative ණ නිත්‍ය ප්‍රකාශනවල ඔන්ලයින් උත්පාදක යන්ත්‍රයක් ලිවීමට මට හැකි විය (අක්ෂරාංක හා අවකාශය පමණි අක්ෂර දැනට සහාය දක්වයි): http://www.formauri.es/personal/pgimeno/misc/non-match-regex/

සඳහා hedeඑය ප්රතිදානයනට:

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

එය ඉහත දෙයට සමාන වේ.

රුබී -2.4.1 හඳුන්වා දුන් දා සිට, අපට රූබීගේ නිත්‍ය ප්‍රකාශනවල නව නොපැහැදිලි ක්‍රියාකරු භාවිතා කළ හැකිය

නිල ලේඛනයෙන්

(?~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මුළුමනින්ම මඟ හැර ඉතිරි රේඛාවලට ගැලපේ.

ඩෙමෝ

කොටස් ක්රියාත්මක කිරීම:

ඉහත රීජෙක්ස් කොටස් දෙකකට බෙදීමෙන් සලකා බලමු.

1. |සංකේතයට පෙර කොටස . කොටස නොගැලපේ .

   ^hede$(*SKIP)(*F)

2. |සංකේතයෙන් පසුව කොටසක් . කොටස ගැලපිය යුතුය .

   ^.*$

1 වන කොටස

රීජෙක්ස් එන්ජිම එහි ක්‍රියාත්මක කිරීම පළමු කොටසේ සිට ආරම්භ කරයි.

^hede$(*SKIP)(*F)

පැහැදිලි කිරීම:

• ^ අපි ආරම්භයේ සිටින බව ප්‍රකාශ කරයි.
• hede නූලට ගැලපේ hede
• $ අපි ඉන්නේ පේළියේ කෙළවරේ කියලා.

එබැවින් නූල අඩංගු රේඛාව hedeගැලපේ. රීජෙක්ස් එන්ජිම පහත දැක්වෙන (*SKIP)(*F)( සටහන: ඔබට මෙසේ ලිවිය (*F)හැකිය(*FAIL) ) ක්‍රියා පදය දුටු විට , එය මඟ හැර තරගය අසාර්ථක වීමට හේතු වේ. |PCRE ක්‍රියාපදයට යාබදව එකතු කරන ලද වෙනස් කිරීම හෝ තාර්කික හෝ ක්‍රියාකරු ලෙස හැඳින්වෙන රේඛාව හැර අනෙක් සියලුම රේඛාවල ඇති සෑම සීමාවක්ම නිරවද්‍ය ලෙස අඩංගු වේ hede. මෙහි නිරූපණය බලන්න . එනම්, එය ඉතිරි නූලෙන් අක්ෂර ගැලපීමට උත්සාහ කරයි. දැන් දෙවන කොටසේ රීජෙක්ස් ක්‍රියාත්මක වනු ඇත.

2 වන කොටස

^.*$

පැහැදිලි කිරීම:

• ^ අපි ආරම්භයේ සිටින බව ප්‍රකාශ කරයි. එනම්, එය පේළියේ ඇති එක හැර අනෙක් සියලුම රේඛා ආරම්භයට ගැලපේ hede. මෙහි නිරූපණය බලන්න .

• .*මල්ටිලයින් ප්‍රකාරයේදී, .නව රේඛා හෝ කරත්ත ආපසු යැවීමේ අක්ෂර හැර ඕනෑම අක්ෂරයකට ගැලපේ. හා *පෙර චරිතය ශුන්ය හෝ ඊට වැඩි වතාවක් නැවත නැවත වනු ඇත. එබැවින් .*මුළු රේඛාවටම ගැලපේ. මෙහි නිරූපණය බලන්න .

  හේයි ඇයි ඔබ එකතු කළේ. * වෙනුවට. +?

  මන්ද යත් .*හිස් රේඛාවකට ගැලපෙන නමුත් .+හිස්ව නොගැලපේ. අපට හැර අනෙක් සියලුම රේඛා ගැලපීමට අවශ්‍යය hede, ආදාන තුළ හිස් රේඛා ඇතිවීමේ හැකියාවක් තිබිය හැකිය. එබැවින් ඔබ .*ඒ වෙනුවට භාවිතා කළ යුතුය .+. .+පෙර චරිතය එක් වරක් හෝ කිහිප වතාවක් පුනරාවර්තනය කරයි. ශුද්ධාසනයේ .*හිස් මාර්ගය තරග මෙතන .

• $ රේඛීය නැංගුරමේ අවසානය මෙහි අවශ්‍ය නොවේ.

එය ඔබගේ කේතයේ ඇති රීජෙක්ස් දෙකකට වඩා නඩත්තු කළ හැකිය, එකක් පළමු තරගය කිරීම, පසුව එය ගැලපෙන්නේ නම් දෙවන රීජෙක්ස් ධාවනය කර ඔබ අවහිර කිරීමට බලාපොරොත්තු වන බාහිර අවස්ථා පරීක්ෂා කර බලන්න. ^.*(hede).* ඔබේ කේතයේ සුදුසු තර්කනයක් තිබිය යුතුය.

හරි, මම පිළිගන්නවා මෙය ඇත්ත වශයෙන්ම පළ කරන ලද ප්‍රශ්නයට පිළිතුරක් නොවන අතර එය තනි රීජෙක්ස් එකකට වඩා තරමක් වැඩි සැකසුම් භාවිතා කළ හැකිය. නමුත් පිටස්තර නඩුවක් සඳහා ඉක්මන් හදිසි විසඳුමක් සොයමින් මෙහි පැමිණි සංවර්ධකයින් සඳහා මෙම විසඳුම නොසලකා හැරිය යුතු නොවේ.

තවත් විකල්පයක් නම්, ධනාත්මක පෙනුමක් එක් කිරීම සහ heheආදාන රේඛාවේ කොතැනක හෝ තිබේදැයි පරීක්ෂා කිරීම , එවිට අපි එය ප්‍රතික්ෂේප කරමු.

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

වචන මායිම් සමඟ.

මෙම ප්‍රකාශනය regex101.com හි ඉහළ දකුණු පුවරුවේ විස්තර කර ඇත , ඔබට එය ගවේෂණය කිරීමට / සරල කිරීමට / වෙනස් කිරීමට අවශ්‍ය නම්, මෙම සබැඳිය තුළ , ඔබ කැමති නම්, සමහර නියැදි යෙදවුම් සමඟ එය ගැලපෙන්නේ කෙසේදැයි ඔබට බලා ගත හැකිය.

රෙජෙක්ස් පරිපථය

jex.im නිත්‍ය ප්‍රකාශන දෘශ්‍ය කරයි:

මෙම 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

රීජෙක්ස් නිෂේධනය තනිවම ප්‍රයෝජනවත් නොවේ, නමුත් ඔබට මංසන්ධියක් ඇති විට, දේවල් රසවත් වන්නේ, ඔබට සම්පූර්ණ බූලියන් කට්ටල මෙහෙයුම් සමූහයක් ඇති බැවිනි: ඔබට “එයට ගැලපෙන කට්ටලය, එයට ගැලපෙන දේවල් හැර” ප්‍රකාශ කළ හැකිය.

පහත දැක්වෙන ශ්‍රිතය ඔබට අපේක්ෂිත ප්‍රතිදානය ලබා ගැනීමට උපකාරී වේ

<?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).)*$එය අලංකාර විසඳුමක් වන අතර, එය අක්ෂර පරිභෝජනය කරන බැවින් හැර වෙනත් නිර්ණායක සමඟ එය ඒකාබද්ධ කිරීමට ඔබට නොහැකි වනු ඇත. නිදසුනක් ලෙස, ඔබට "හෙඩ්" නොමැතිවීම සහ "හහා" තිබේද යන්න පරීක්ෂා කිරීමට අවශ්‍ය බව පවසන්න. අක්ෂර පරිභෝජනය නොකරන බැවින් මෙම විසඳුම ක්‍රියාත්මක වේ:

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

වචනයක් අඩංගු නොවන රේඛාවකට ගැලපෙන ලෙස PCRE හි පසුගාමී පාලන ක්‍රියාපද භාවිතා කරන්නේ කෙසේද

මෙන්න මම මීට පෙර භාවිතා නොකළ ක්‍රමයක්:

/.*hede(*COMMIT)^|/

එය ක්‍රියාත්මක වන ආකාරය

පළමුව, එය රේඛාවේ කොතැනක හෝ "හෙඩ්" සොයා ගැනීමට උත්සාහ කරයි. සාර්ථක නම්, මේ අවස්ථාවේදී,(*COMMIT) එන්ජිමට අසමත් වූ අවස්ථාවක පසුබැසීමට පමණක් නොව, එම අවස්ථාවේ දී තවත් ගැලපීමක් කිරීමට උත්සාහ නොකරන්න. පසුව, නොගැලපෙන දෙයක් ගැලපීමට අපි උත්සාහ කරමු (මේ අවස්ථාවේ දී ^).

පේළියක "හෙඩ්" අඩංගු නොවේ නම්, දෙවන විකල්පය, හිස් උප රටාවක්, විෂය නූලට සාර්ථකව ගැලපේ.

මෙම ක්‍රමය negative ණාත්මක පෙනුමකට වඩා කාර්යක්ෂම නොවේ, නමුත් මම සිතුවේ යමෙකු එය නිර්‍මාණ කර වෙනත් වෙනත් රසවත් යෙදුම් සඳහා භාවිතයක් සොයා ගන්නේ නම් මම එය මෙහි විසි කරන බවයි.

සරල විසඳුමක් වන්නේ ක්‍රියාකරු නොවන අය භාවිතා කිරීමයි !

ඔබගේ if ප්‍රකාශය "අඩංගු" ගැලපීමට අවශ්‍ය වන අතර "බැහැර" වලට නොගැලපේ.

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

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

රෙජෙක්ස් හි නිර්මාණකරුවන් අපේක්‍ෂා කළේ මෙහෙයුම්කරුවන් නොවන බවයි.

උපස්ථරයක් අඩංගු නොවන රේඛාවක කොටස් (සම්පූර්ණ රේඛාවලට සාපේක්ෂව) ගැලපෙන රීජෙක්ස් එකක් ලිවීමට උත්සාහ කරන අතරතුර සමහර විට ඔබ මෙය ගූගල්හි සොයා ගනු ඇත. හදුනා ගැනීමට මට ටික වේලාවක් ගත කරන්න, එබැවින් මම බෙදා ගන්නෙමි:

නූලක් ලබා දී ඇත: <span class="good">bar</span><span class="bad">foo</span><span class="ugly">baz</span>

<span>"නරක" උපස්ථරය අඩංගු නොවන ටැග් ගැලපීමට මට අවශ්‍යය .

/<span(?:(?!bad).)*?>ගැලපෙනු ඇත <span class=\"good\">සහ <span class=\"ugly\">.

වරහන් වර්‍ග දෙකක් (ස්ථර) ඇති බව සැලකිල්ලට ගන්න:

• අභ්‍යන්තරය the ණාත්මක පෙනුම සඳහා වේ (එය අල්ලා ගැනීමේ කණ්ඩායමක් නොවේ)
• පිටත කෙළවර රූබි විසින් ග්‍රහණය කර ගැනීමේ කණ්ඩායමක් ලෙස අර්ථකථනය කර ඇති නමුත් එය අල්ලා ගැනීමේ කණ්ඩායමක් වීමට අපට අවශ්‍ය නැත, එබැවින් මම එකතු කළෙමි?: එය ආරම්භයේ දී සහ එය තවදුරටත් අල්ලා ගැනීමේ කණ්ඩායමක් ලෙස අර්ථකථනය නොකෙරේ.

රූබි හි නිරූපණය:

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/ ගැලපීම අඩංගු නොවන රේඛා ලබා ගැනීමට විධාන රේඛාව භාවිතා කළ හැකිය, නැතහොත් රීජෙක්ස් ගැලපීම cc.dl /hede/අඩංගු රේඛා මකා දැමීමට විධාන රේඛාව භාවිතා කරන්න . ඔවුන් එකම ප්රති result ලය ඇත.

මට තවත් උදාහරණයක් එක් කිරීමට අවශ්‍ය වූයේ ඔබ X පේළිය අඩංගු සම්පූර්ණ පේළියකට ගැළපීමට උත්සාහ කරන්නේ නම්, නමුත් Y නූල් අඩංගු නොවේ .

නිදසුනක් ලෙස, අපගේ URL / string හි " රසවත් සංග්‍රහ " අඩංගු දැයි පරීක්ෂා කර බැලීමට අවශ්‍ය යැයි කියමු , එහි කොතැනකවත් " චොකලට් " අඩංගු නොවන තාක් කල් .

මෙම රීජෙක්ස් රටාව ක්‍රියාත්මක වනු ඇත (ජාවාස්ක්‍රිප්ට් වලද ක්‍රියා කරයි)

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

(උදාහරණයක් ලෙස ගෝලීය, බහු රේඛා ධජ)

අන්තර්ක්‍රියාකාරී උදාහරණය: https://regexr.com/53gv4

තරග

(මෙම යූආර්එල්වල "රසවත් සංග්‍රහ" අඩංගු වන අතර "චොකලට්" ද අඩංගු නොවේ)

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

නොගැලපේ

(මෙම යූආර්එල්වල කොහේ හරි "චොකලට්" අඩංගු වේ - එබැවින් ඒවා "රසවත් සංග්‍රහ" අඩංගු වුවද ඒවා නොගැලපේ)

• 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