regexp kiértékelési érdekesség

Az egrep lesz ott slendrián a színezésével.

Itt kizárólag az 'a'-betűket színezi végig, ami ép elmével értelmezhető úgy, hogy számos helyen talált legalább egy a-t, amit az a-k mohó felzabálása után már nem követett semmi a kifejezés hátrelévő részéből.

Az első verziód csak az első négy a-t színezi be?
Mert nálam az összeset.

A második példádban meg a teljes stringre illeszkedik a megadott regexp, miért gond, hogy beszínezi az egészet?
Én nem értek/látok valamit?

Mondjuk az furcsa, hogy pl. a python re modulban a második mintára egyetlen egyezést sem talál, de ez lehet, hogy valami pythonos galádság.

Aki tudja, csinálja, aki nem tudja, tanítja... Hm... igazgatónak talán még jó lennék. :)

Az első példa egrep esetén kiszínezi az összes a betűt, mert a regexp-hez képest az összes egyezést megkeresi. Az alább az összes egyezést mutatja
echo aaaababababcabcabc | egrep -o --color "a+"
aaaa
a
a
a
a
a

A helyes találat csak aaaa lenne. A mohóság csak + jelre értendő.

A második pedig így meccsel:
a ->1*a 0*ab 0*abc
...
aaaa -> 4*a 0*ab 0*abc
aaaab -> 3*a 1*ab
...
aaaababababc -> 3*a 3*ab 1*abc
stb.

Nem olyan nehéz ez. Az elképzelhető legtágabb illeszkedés fog érvényre jutni. Habár az 'aaaa' illeszkedik az 'a+'-ra, elegendő csupán 3 'a'-ra azt mondani, hogy illeszkedik, utána csak az 'ab'-kat nézni. Ily módon illeszkedik az 'abababab' az '(ab)*'-ra, de ismét elegendő csupán 3 'ab'-ra ráhúzni a regexet. Az utána következő 'abc'-k már az '(abc)*'-ra fognak illeszkedni.

A következő ábra alapján már triviális lesz:


a+ | (ab)* | (abc)*
aaa| ababab| abcabcabc


Látható, hogy volt lehetőségünk a teljes sort kijelölni vele, tehát garantáltan az elképzelhető legtágabb illeszkedés jutott érvényre. A regexek világa gyönyörű! Nagyon szeretem.

A kérdés az, hogy az a+ az négyre _kell_, hogy illeszkedjen, vagy elég 3-ra is, mivel van még keresendő egyezés.

Ha az a{4}(ab)*(abc)* is kiszínez mindent, akkor kezdj el aggódni szerintem :)

--
PtY - www.onlinedemo.hu

zamboriz meglehetősen velős hozzászólásában van a lényeg. Egy regexpnél a szabály az, hogy az első előfordulást fogja megtalálni. Kedves példa rá:

$ echo zabaabaaab | sed -E 's/a*/X/'
Xzabaabaaab
$ echo zabaabaaab | sed -E 's/a+/X/'
zXbaabaaab

Ellenben ha adott pozícióban többféle hosszúságban lehet találni, akkor ebből a pozícióból kiindulva a lehető leghosszabbat fogja kiválasztani. Az, hogy a RE egyes részei hol fejeződnek be és hol kezdődnek a megtalálásnál, az csak a legvégén dől el. Ezt grep-pel még színezéssel sem igazán lehet kimutatni (mert kicsit másént viselkedik, mint az néhányaknak logikus lenne), de pl. sed-del igen.

$ echo aaaababababcabcabc | sed -E 's/a+/X/'
Xbabababcabcabc
$ echo aaaababababcabcabc | sed -E 's/a+(ab)*(abc)*/X/'
X
$ echo aaaababababcabcabc | sed -E 's/a{4}(ab)*(abc)*/X/' # Pty javaslata
Xbabababcabcabc


http://www.phpliveregex.com/

Itt nézegettem, a + és a * a kiértékelés sorrendjén változtat szerintem.

(a+)((ab)+)((abc)+)

Itt olyan mintha jobbról balra menne, abc-t, ab-t, a-t keresne, és így az egészre illeszkedik:

Array
(
    [0] => aaaababababcabcabc
    [1] => aaa
    [2] => ababab
    [3] => ab
    [4] => abcabcabc
    [5] => abc
)

(a+)((ab)*)((abc)*)

Ez meg balról jobbra, a-t, ab-t, abc-t keresne, ezért nem illeszkedik:

Array
(
    [0] => aaaa
    [1] => aaaa
    [2] => 
    [3] => 
    [4] => 
)

(a+)((ba)*)((bca)*)

Viszont értelemszerűen illeszkedik (a, ba, bca a sorrend):

Array
(
    [0] => aaaababababcabca
    [1] => aaaa
    [2] => bababa
    [3] => ba
    [4] => bcabca
    [5] => bca
)

A miértre én sem tudom a választ.

(Szerk.: most látom hogy neked pont nem így van, akkor ez maga a kérdés volt, sorry. Az egrep mindkettőt végig kiszínezi, de akkor talán a jobbról balra dolog miatt lehet?)

.