[rozdajozadarmo]

#programowanie A ty jaki masz dzisiaj powód, żeby znowu nie nauczyć się wyrażeń regularnych?

[G.....p]

@rozdajozadarmo: Już umiem ( ͡° ͜ʖ ͡°)

[I.....n]

@rozdajozadarmo: bo na wykopie napisali, że to zło i nie wolno ich używać.

[binerek]

@rozdajozadarmo: parsować htmla mogę w inny sposób ( ͡° ͜ʖ ͡°)

[Viters]

@rozdajozadarmo: Bo jedyne co parsuje to HTML #pdk

[programuje_dla_hajsu]

@rozdajozadarmo: w ogóle jak sie tego uczy? Ja sie nauczyłem podczas pracy ( ͡° ͜ʖ ͡°)

[rozdajozadarmo]

@programuje_dla_hajsu: ten wpis to taka autoironia. Zawsze się wzbraniałem przed nauką regexów aż mnie życie zmusiło., tzn przypadek był na tyle specyficzny, że nie było gotowca w sieci i nie dało się go rozwiązać bez użycia wyrażenia regularnego.

Uprzedzajac pytanie: tak, jest mi wstyd :)

[p.....i]

@rozdajozadarmo: dla mnie regexpy to jest takie zło konieczne, których staram się unikać z uwagi na "zaciemnianie kodu". Kod ma być czytelny nawet wtedy, gdy wrócę do niego po dwóch latach, a regexpy z definicji mi to utrudniają.

Czytelność > Finezja.

[rozdajozadarmo]

@piot-rabi: ja też sobie zawsze w ten sposób usprawiedliwiałem swoją nieudolność w tej dziedzinie :)

[p.....i]

@rozdajozadarmo: to nie jest nieudolność, tylko świadome działanie zgodne z filozofią Wujka Boba.

Regexpy trochę bardziej skomplikowane niż adres email po kilku latach można rozkminiać nawet parę godzin. To trochę jak z całkami i pochodnymi. Z każdej liczby wyciągniesz pochodną (napisanie regexpa), ale z nie każdej całki wyciągniesz później liczbę (odszyfrowanie regexpa aby go później przerobić).

Maintenance is a key.

[rozdajozadarmo]

@piot-rabi:
Jasne. Zgadzam się z tobą. Poprzednia wypowiedź była pół żartem, pół serio. Btw, do rozszyfrowania regexów polecam: https://regex101.com/

[kapelusz]

Regexpy trochę bardziej skomplikowane niż adres email

@piot-rabi: http://www.ex-parrot.com/pdw/Mail-RFC822-Address.html

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[["()<>@,;:\".[\]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[\]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[["()<>@,;:\".[\]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\](?:(?:\r\n)?[
\t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)?[
\t])+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[["()<>@,;:\".[\]]))|[([^[\]\r\]|\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\".[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[["()<>@,;:\".[\]]))|"(?:[^\"\r\]|\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\".[\]

[p.....i]

@kapelusz: dokładnie ʕ•ᴥ•ʔ

[fruity]

@rozdajozadarmo: idę sie schlac pozdrawiam

[denwood]

@piot-rabi: Tez kiedys miałem podobne podejście .. dopóki nie zacząłem ogarniać regexpów. Jeśli mowa o czytelności,
rozpraszanie uwagi między 70 liniami 30tu warunków, poleceń, pętli a zwięzły regexp.match w jednej linii?
pisanie kodu > lanie wody
Kwestia obycia się z nimi zarówno w pisaniu jak i czytaniu. Nie mówię o skrajnościach jak przykład @kapelusz bo to jest jakiś kosmos, ale w codziennym użyciu regexpy długości kilkunastu-kilkudziestu znaków oszczędzają dziesiątki linii kombinowania,

[p.....i]

@denwood: nie mówię, aby regexpy wyrzucić, bo do pewnych spraw się przydają, tyle tylko, że często i gęsto można to zrobić lepiej i czytelnie. W C# mamy Linq, w innych technologiach też znajdzie się coś funkcyjnego. Do tego należy pamiętać, jakim zespołem dysponujesz i o tym, że to niekoniecznie Ty będziesz ten kod później utrzymywał.

Krótkie, zwięzłe "jednolinijkowce" w regexp to ok, ale jak ktoś wali coś powyżej 30-40 znaków to