[PHP][RegExp] Krijg niet dejuiste data met regexp

[gitaarwerk]

Hallo :-)

Voor een opdracht ben ik bezig een twitter applicatie te maken. Nu wil ik graag een paar dingen filteren:

voorbeeldzin: "@twitternaam: #project Ziet er goed uit! Blijf doorgaan, kijk ook even naar @twitternaamtwee !"

Wat wil ik doen met de filter:
- filteren op @namen, de eerste moet worden verwijderd startend met '@' eindigend op ':' ), maar ik moet deze naam wel worden opgeslagen in een array/string

- #namen moet worden verwijderd, startend met een '#', ook hier moet deze opgeslagen worden in een array/string

Zover ik ben gekomen momenteel met tutorials volgen is op deze code:

code:

preg_match_all('[(@.*:)|(#.*)]', $message, $afdeling);

Wat ik weet is dat opzich de code met de @~: wel goed zit, qua herkenning, maar de # nog niet,..

Ik begrijp er na zo een goeie 10 uur op zitten nog weinig van moet ik zeggen. Google, php.net en de links hier in de FAQ hebben me niet verder dan dit geholpen. Jammer dat de tutorial van drm en andere links wat dood waren.

Hopelijk kan iemand mij hier een schopje in de juiste richting opgeven. Ik wil het heel graag leren, maar oef .

Edit: een expert is momenteel even aan het helpen. Misschien zometeen wel een deelbare oplossing

[ Voor 4% gewijzigd door gitaarwerk op 06-04-2009 23:18 ]

[kaesve]

zoals je regex nu staat matched hij ook ALLES na een #. Dus ook spaties. (#.*\b) zou dus wel moeten werken (waar \b dus staat voor wordboundry)? ik ben geen regex-expert, dus correct me if I'm wrong :]

[Guillome]

moet het niet zoiets zijn?
/(@[^:]+:|@[^\Z]+\Z|#[^\s]+)/

[kaesve]

Guillome schreef op maandag 06 april 2009 @ 23:45:
moet het niet zoiets zijn?
/(@[^:]+:|@[^\Z]+\Z|#[^\s]+)/

matched je 2e deel (@[^\Z]+\Z) niet alles dat met een @ begint en met een newline/end-of-subject eindigt met daartussen elk symbool dat geen newline/end-of-subject is (in dit geval dus de hele string)? of heb ik \Z verkeert begrepen?

[Guillome]

\Z is einde van je string

[kaesve]

dat begrijp ik.. maar als ik het zo lees staat er (vrij vertaald):

matched als: (sub)-string begint met @ gevolgt door een of meerdere symbolen die niet het einde van je string markeren gevolgt door het einde van je string.

dat betekend dus dat "@twitternaam: #project Ziet er goed uit! Blijf doorgaan, kijk ook even naar @twitternaamtwee !" in zijn geheel wordt gematched.. immers heb je hier helemaal aan het begin een @ gevolgt door verscheidene symbolen die niet het einde van de string markeren met aan het einde het einde van je string. toch?

[Janoz]

Waarom wil je dit met een regexp doen? Wat handig werken met indexOf en substring werkt volgens mij veel makkelijker.

[Guillome]

oh ja dan moet er een \s bij [^\s\Z]\Z
Ik zal er morgen even beter naar kijken als er nog geen antwoord op is

[Guillome]

PHP:

  $s = "@twitternaam: #project Ziet er goed uit! Blijf doorgaan, kijk ook even naar @twitternaamtwee !";

  preg_match_all("/@[^:]+:|@[^\s\Z]+[\s\Z]|#[^\s]+/", $s, $m);

[ Voor 121% gewijzigd door Guillome op 07-04-2009 08:50 ]

[Woy]

Ik ben het eens met Janoz. Waarom wil je het met Regular Expressions doen. Alhoewel regexps heel krachtig kunnen zijn, is het vaak erg onduidelijk en overbodig.

Daarbij wil ik ook even op de sig van Creepy wijzen

Some people, when confronted with a problem, think "I know, I'll use regular expressions." Now they have two problems. — Jamie Zawinski

[wackmaniac]

Woy schreef op dinsdag 07 april 2009 @ 08:59:
Ik ben het eens met Janoz. Waarom wil je het met Regular Expressions doen. Alhoewel regexps heel krachtig kunnen zijn, is het vaak erg onduidelijk en overbodig.

Daarbij wil ik ook even op de sig van Creepy wijzen

[...]

Als, zoals ik het begrijp, de TS alle voorkomens van @twitternaam in een string wil ophalen is een goed ontworpen RegEx natuurlijk veel gunstiger. Hoewel ik er geen fan van ben zou ik in dit geval toch ook kiezen voor een regex.

[Woy]

wackmaniac schreef op dinsdag 07 april 2009 @ 09:32:
[...]


Als, zoals ik het begrijp, de TS alle voorkomens van @twitternaam in een string wil ophalen is een goed ontworpen RegEx natuurlijk veel gunstiger. Hoewel ik er geen fan van ben zou ik in dit geval toch ook kiezen voor een regex.

Hoezo is een goed ontworpen RegEx natuurlijk veel gunstiger? Ik heb die discussie al vaker gehad met een collega, maar een RegEx is echt niet zo heel snel als de meeste mensen denken. Het is best een krachtige tool, maar dat betekent niet dat je het maar voor alle string operaties moet gebruiken.

Hier kun je toch ook gewoon af met simepel IndexOf methodes?

[Guillome]

Waarom meerdere regels, als het ook mooi in 1 kan?

[Woy]

Guillome schreef op dinsdag 07 april 2009 @ 09:46:
Waarom meerdere regels, als het ook mooi in 1 kan?

Korte code heeft bij mij niet perse de voorkeur.

code:

string = DoRegex( /(@[^:]+:|@[^\Z]+\Z|#[^\s]+)/ )

Vind ik nou niet echt leesbaar

code:

startIndex = IndexOf( '@' );
endIndex = IndexOf( ':' );

string = SubString( startIndex, endIndex );

Vind ik ieder geval een stuk leesbaarder en beter onderhoudbaar.

[Creepy]

wackmaniac schreef op dinsdag 07 april 2009 @ 09:32:
[...]


Als, zoals ik het begrijp, de TS alle voorkomens van @twitternaam in een string wil ophalen is een goed ontworpen RegEx natuurlijk veel gunstiger. Hoewel ik er geen fan van ben zou ik in dit geval toch ook kiezen voor een regex.

Als je code kan bouwen die met 1 keer de string doorlopen alle voorkomens er direct uit kan halen is dat gegarandeerd niet minder gunstig dan een regexp en vaak nog makkelijker leesbaar qua code ook. Wat is het voordeel van ene regexp dan nog?

[Woy]

Creepy schreef op dinsdag 07 april 2009 @ 09:51:
[...]

Als je code kan bouwen die met 1 keer de string doorlopen alle voorkomens er direct uit kan halen is dat gegarandeerd niet minder gunstig dan een regexp en vaak nog makkelijker leesbaar qua code ook. Wat is het voordeel van ene regexp dan nog?

En dan nog zou ik het pas optimaliseren als het echt nodig is. De pseudo code die ik hierboven geef is inderdaad niet het meest performant ( Al moet ik nog maar zien dat een RegExp sneller is ), je kan het eenvoudig vertalen naar een loopje die eenmaal door de string loopt, maar het is gewoon goed leesbaar, en 99,9% kans dat je er geen performance problemen mee hebt.

[ Voor 3% gewijzigd door Woy op 07-04-2009 09:55 ]

[wackmaniac]

Woy schreef op dinsdag 07 april 2009 @ 09:51:
[...]

Korte code heeft bij mij niet perse de voorkeur.

code:

string = DoRegex( /(@[^:]+:|@[^\Z]+\Z|#[^\s]+)/ )

Vind ik nou niet echt leesbaar

code:

startIndex = IndexOf( '@' );
endIndex = IndexOf( ':' );

string = SubString( startIndex, endIndex );

Vind ik ieder geval een stuk leesbaarder en beter onderhoudbaar.

Nou hoef je niet meteen je antipathie tegen regex' te spuien. In jouw voorbeeld vind je alleen de eerste @twitternaam:, terwijl de TS volgens mij aangaf dat hij alle voorkomens wil hebben, dan is onderstaande toch net zo leesbaar naar mijn idee:

PHP:

$matches = array();
// haalt alle voorkomens van @twitternaam[:] op
preg_match ( 'moeilijke regex' , $string , $matches );
// doe iets met je $matches array

[Woy]

wackmaniac schreef op dinsdag 07 april 2009 @ 10:10:
[...]
Nou hoef je niet meteen je antipathie tegen regex' te spuien. In jouw voorbeeld vind je alleen de eerste @twitternaam:, terwijl de TS volgens mij aangaf dat hij alle voorkomens wil hebben, dan is onderstaande toch net zo leesbaar naar mijn idee:

Ik heb helemaal geen antipathie tegen regexen, maar ik denk dat er vaak te snel naar gegrepen word. Ik gebruik soms zelf ook reguliere expressies. Mijn voorbeeld was ook niet bedoeld als complete oplossing voor de TS, maar meer om aan te geven dat kortere code niet perse duidelijker hoeft te zijn.

PHP:

$matches = array();
// haalt alle voorkomens van @twitternaam[:] op
preg_match ( 'moeilijke regex' , $string , $matches );
// doe iets met je $matches array

Ja het is perfect duidelijk wat het doet, maar als er nou net wat aan de syntax ( van twitter ) veranderd, of er toch een bug inzit is het een stuk lastiger aan te passen.

Mijn voorbeeld is met een simpel loopje makkelijk aan te passen zodat alle twitter namen opgehaald worden. Je krijgt dan nog steeds geen brij aan code die niet meer te overzien is, maar gewoon simpele code die zelfs elke startende programmeur kan begrijpen.

Dat je je code moet documenteren geeft al aan dat de code zelf minder duidelijk is. Tuurlijk moet je je code altijd documenteren, maar het is vaak fijn als ook in een oogopslag aan de hand van de code duidelijk is wat er gebeurt.

[ Voor 8% gewijzigd door Woy op 07-04-2009 10:40 ]

[Guillome]

Regel1 is overbodig
* gebeurt

En ik denk als je beetje thuis bent in RegExp en dit in 10 min kan uitvogelen, dat je het zo kan aanpassen waar nodig. Dat andere is misschien leesbaarder, maar 1 RegExp in dit geval vind ik programmeertechnisch gezien wel wat netter. Maar dit is denk ik ook een persoonlijke voorkeur.

[ Voor 87% gewijzigd door Guillome op 07-04-2009 10:31 ]

[Woy]

Guillome schreef op dinsdag 07 april 2009 @ 10:28:
* gebeurt

offtopic:
Ja ik moet mijn post idd wat beter doorlezen, aangezien ik dislectisch ben, maar als ik ook ergens anders mee bezig ben schiet dat er wel eens bij in

En ik denk als je beetje thuis bent in RegExp en dit in 10 min kan uitvogelen, dat je het zo kan aanpassen waar nodig.

Je kan het mischien wel in 10 minuten uitvogelen, maar het is IMHO wel veel foutgevoeliger. 1 character kan immers de complete betekenis van je Regexp veranderen.

Dat andere is misschien leesbaarder, maar 1 RegExp in dit geval vind ik programmeertechnisch gezien wel wat netter. Maar dit is denk ik ook een persoonlijke voorkeur.

Ik snap niet waarom het voor een simple probleem programmeertechnisch beter zou zijn? Leesbaarheid vind ik namenlijk een erg belangrijk deel van programmeren. Het komt natuurlijk wel eens voor dat je op een stuk code uitkomt wat niet compleet duidelijk is, en wat je d.m.v. commentaar moet verduidelijken. Maar als er gewoon een goed leesbaar alternatief is, zou ik daar persoonlijk toch voor kiezen.

[ Voor 15% gewijzigd door Woy op 07-04-2009 10:45 ]

[Guillome]

1 karakter kan je hele pakket waar dan ook om zeep helpen, dus dat vind ik een nutteloos argument.
En als je meerdere dingen uit een string wilt filteren, en het kan in 1 regel, waarom zou het dan netter zijn om het in meerdere regels met loopjes enzo te doen?

edit:

Woy schreef op dinsdag 07 april 2009 @ 10:43:
[...]
zou ik daar persoonlijk toch voor kiezen.

En is dit dus idd meer een persoonlijke smaak dan een regel.

[ Voor 30% gewijzigd door Guillome op 07-04-2009 10:50 ]

[Woy]

Guillome schreef op dinsdag 07 april 2009 @ 10:45:
1 karakter kan je hele pakket waar dan ook om zeep helpen, dus dat vind ik een nutteloos argument.

Maar ben je het niet met me eens, dat je in een regexp sneller een typefout maakt die je over het hoofd zit dan bij een simpele indexof? Als je bij indexof het verkeerde character gebruikt gaat het idd ook mis, maar ik zie ieder geval in een oogopslag wat er mis is, bij een regexp moet ik eerst de hele regexp uit gaan pluizen.

En als je meerdere dingen uit een string wilt filteren, en het kan in 1 regel, waarom zou het dan netter zijn om het in meerdere regels met loopjes enzo te doen?

Ik zeg ook niet dat het netter is om het in meerdere regels te doen. Ik zeg alleen dat het niet perse netter is om het in minder regels code te doen.

En is dit dus idd meer een persoonlijke smaak dan een regel.

Er is natuurlijk geen regel voor, maar de stelling dat het beter is om het zo kort mogenlijk te doen vind ik gewoon vreemd. Zeker aangezien het ontwikkelen met een regular expression helemaal niet sneller is/hoeft te zijn. Ook opslagruimte lijkt me niet echt een issue.

Zou jij dan altijd voor de korte oplossing kiezen als er ook een langere duidelijkere oplossing is?

[Guillome]

Woy schreef op dinsdag 07 april 2009 @ 10:55:
[...]

Maar ben je het niet met me eens, dat je in een regexp sneller een typefout maakt die je over het hoofd zit dan bij een simpele indexof? Als je bij indexof het verkeerde character gebruikt gaat het idd ook mis, maar ik zie ieder geval in een oogopslag wat er mis is, bij een regexp moet ik eerst de hele regexp uit gaan pluizen.

Ja opzich wel, maar voordat je een regexp gebruikt, test je m toch eerst goed? In een losse file. Werkt ie? Dan zet je m in je project.

Ik zeg ook niet dat het netter is om het in meerdere regels te doen. Ik zeg alleen dat het niet perse netter is om het in minder regels code te doen.
[...]

En ik zeg het idem niet andersom Ik denk nogmaals dat het, zeker in dit geval, meer een persoonlijke smaak is.

Zou jij dan altijd voor de korte oplossing kiezen als er ook een langere duidelijkere oplossing is?

Ja vaak wel denk ik. Maar opsplitsen van korte dingen, als het een te lange regel wordt, vind ik wel weer netjes.
Bijv: (al zou ik dit niet opsplitsen, dit is kort genoeg voor 1 regel)

PHP:

$r = new RegExp(blabla);
preg_match_all($r, $s, $m);

En meer van zulks. Persoonlijk vind ik dat wel netter dan

PHP:

while (weet ik veel wat)
{
  $start = indexOf($s, "@")
  $str = substr()
}

oid

[ Voor 3% gewijzigd door Guillome op 07-04-2009 11:02 ]

[Verwijderd]

Guillome schreef op dinsdag 07 april 2009 @ 11:01:
[...]

Bijv: (al zou ik dit niet opsplitsen, dit is kort genoeg voor 1 regel)

PHP:

$r = new RegExp(blabla);
preg_match_all($r, $s, $m);

En op deze manier kan je met duidelijke naamgeving ook het regexp gebruik in je code duidelijk en leesbaar maken. Met duidelijke naamgeving geef je dan aan wat de regex matched waardoor het begrijpen van de regexp ook weer makkelijker wordt.

[gitaarwerk]

wow.. ik heb een beetje weinig tijd gehad in de tussentijd, maar had niet zoveel reacties verwacht.

Ik heb even gekeken naar de oplossing van Janoz. Die raakt inderdaad het ook, alleen ik heb graag hetgeen in een collectie(array) zodat ik meerdere bewerkingen binnen een regel kan doen. Op een ~400 berichten met content plaatsing en hier ook bewerkingen op uitvoeren word het een beetje rommelig vind ik.

Ik heb daarom de hulp ingeroepen van een vriend van mijn gf, die heel toevallig een prima hacker is en regexp begrijpt.

PHP:

function extractData($line)
        {

            $list = Array();

            $matcher = "/\@(.*?)(: | )(.*?)/";
            if (($total_users = preg_match_all($matcher, $line, $matches)) > 0)
            {
                /* let's fill our list of users */
                for ($i = 0; $i < $total_users; $i++)
                {
                    $list[$i] = Array('user' => $matches[1][$i], 'message' => "", 'type' => "");

                    /* now let's get each user's messages */
                    $matcher = "/\@" . $matches[1][$i] . "(: | )(.*?)(\@|$)/";
                    if (preg_match($matcher, $line, $msgmatches))
                    {
                        $list[$i]['message'] = $msgmatches[2];
                    }

                    /* and finally, from these messages we extract their type */
                    $matcher = "/(#\S*)/";
                    if (($total_types = preg_match_all($matcher, $list[$i]['message'], $typematches)) > 0)
                    {
                        for ($j = 0; $j < $total_types; $j++)
                        {
                            $list[$i]['type'] .= $typematches[0][$j] . ' '; 
                        }
                    }
                } 
            }
            return $list;
        }

\
Dit was de oplossing.
Voor als iemand deze wil gebruiken:

Het is wel dat hij de berichten split, maar die kan je weer aan elkaar naaien. Dat is best fijn, want zo kan je ook berichten opdelen naar gebruikers.

Vraag nog aan de mensen hier, is er toevlalig een goed boek over reguliere expressies? het is natuurlijk fijn als iedereen het hier kan oplossen, maar misschien ook fijn om het eens zelf te kunnen en wellicht iemand hier weer te helpen .

Ik hoop dat de bovenstaande code mensen kunnen gebruiken ook.

even over bovenstaande reacties:

code:

/(@[^:]+:|@[^\Z]+\Z|#[^\s]+)/

heb even niet de lijst bij de hand, maar ik snap nog niet hoe de delimiter met de spatie werkt. Ik dacht/las namelijk dat de \s niet goed werkte, en daarvoor de [[:space:]] was, helaas werkte die nog minder. matchen is natuurlijk een ding, dan het verwijderen, maar goed, dat is zelfs als ik er niet goed in ben goed te doen (rommelig met str_replace met de matches)

in ieder geval nogmaals hartelijk dank, ik snap wel weer een stukje extra regexp