Koliko jako volite regularne izraze

Evo jedna tema, za iskazivanje ljubavi prema regularnim izrazima?

Koliko jako volite regularne izraze od 1 - 100? :slight_smile:

Ja bi im dao i veću ocjenu od 100 da se može…a iznenađen sam koliko ljudi preskoči to gradivo. Npr. u firmu gdje sam došao, od 15-ak IT nitko ništa s njima nije radio… nepoznanica im.

Ovako generalno ljude koje srećem…isto to preskočili.

Ja bi ih isto moguće preskočio da nisam imao mentora koji mi je u najranijim danima vikao: “To se rješava sa regularnim izrazima, oni su zlato za to…a sve ostalo je muka Isusova”.

Ja sam naravno uvijek išao “logičnijim” odabirom i trpio muku Isusovu, jer mi je to bilo quick and dirty riješenje. A on bi me svaki puta isponova podbo kada bi vidio da nisam uzeo regularne izraze gdje sam mogao.

I tako, prošle godine da ih nisam dirao. I onda sam bio na jednom projektu gdje ih se stvarno isplatilo naučiti, i nakon toga prosvjetljenje. To je tako koristan i divan alat da najtoplije savjetujem svakog programera da si odvoji jedno 15 sati (puno sam i rekao) na učenje istih i sigurno neće požaliti.

Heto, potaknut činjenicom da ih puno ljudi preskoči…motiviran sam bio druge motivirati.
A upravo me razveselila činjenica kako sam lako sa regularnim izrazima u jednom meni nepoznatom projektu od tonu skripti našao Google Map key gdje se nalazi…za 10 sekundi :smiley: :smiley:

Kako sam ga našao? Tko zna regex-e, zna i odgovor na pitanje :wink:

žž.

Ja nisam programer, ali regex, xpath su mi najdrazi alati. Regex obozavam, ali moram ljude razocarati da 15 sati ucenja regexa mozda naucis samo mali dio njega. Bit regexa je u jednoj liniji izvadit bitno, ali ima regexa koji su dugacki kao ponedjeljak, sve ovisi sot ti treba…

1 Like

Naj plašiti ljude. Da se jako puno naučiti o regularnim izrazima i u tri sata …a kamoli 15. Pogotovo ako ti ih netko u startu objasni, da se lakše krene…

Naravno, kao i sve…možemo u dubinu sa učenjem ići beskonačno. Ali kada kreneš iz nule, u prvih nekoliko sati si više napredovao…nego što ćeš ikada kasnije. Jer: nešto znati / ništa znati = beskonačni napredak.

I zaista se isplati makar te osnove naučiti i s time se može već jako puno život olakšati za određene situacije.
A kada se uhvati koncept, kasnije se oni lako zamrse i postanu kobasice… :slight_smile:

Regexi su brutalna stvar, u mojem mvc-u, router mi je 70 linija code-a, controller mi moze biti bilo gdje i ruta bilo kakva.

Kod baza se ne preporuca regex, ako ima drugih nacina, koristiti druge nacine na bazi, ako nema onda regex. Regex na bazi je zadnja opcija.

Opet ovisi na bazi koliko ima recorda za obradu i koliko traje, ako nekog zadovoljava i nije mu bitna brzina onda regex.

1 Like

ne?

(?:(?:\r\n)?[ \t])(?:(?:(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t] )+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?: \r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[^()<>@,;:\".[] \000-\031]+(?:(?:frowning: ?:\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]))&lt;(?:(?:\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])(?:[^()<>@,;:\".[] \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])))&gt;(?:(?:\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-\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])))|(?:[^()<>@,;:\".[] \000- \031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[]]))|"(?:[^"\r\]|\.|( ?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))&lt;(?:(?:\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]))?(?:[^()<>@,;:\".[] \0 00-\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-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\". []]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t]))(?:.(?:(?:\r\n)?[ \t])(?:[ ^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[] ]))|[([^[]\r\]|\.)](?:(?:\r\n)?[ \t])))&gt;(?:(?:\r\n)?[ \t]))(?:,\s( ?:(?:[^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\ “.[]]))|”(?:[^"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))(?:.(?:frowning: ?:\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])))|(?: [^()<>@,;:\".[] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[["()<>@,;:\".[\ ]]))|"(?:[^"\r\]|\.|(?:(?:\r\n)?[ \t]))"(?:(?:\r\n)?[ \t]))&lt;(?:(?:\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])(?:[^()<>@,;:\".[] \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])))&gt;(?:frowning: ?:\r\n)?[ \t]))))?;\s)

Ovo mene plasi… Ovo kao da je neko napisao kineski…

1 Like

Da, ali koliko svakodnevno u praksi treba tako nešto? :slight_smile:
Za selektirati ono što nam najčešće treba…regularni izgledaju poprilično pitomo.

Evo kratko i jednoistavno, ovo vadi mene na svakom pageu ovog foruma… hahaha

Ovaj alat za testiranje izraza mi nekako djeluje puno ugodniji od tog tvoga:
https://regexr.com/

možda griješim…nisam se previše zagledao u tvoj, ali onako na prvu:
spora stranica , raspada se vizualni dio …nema baš user friendly pregled selektiranih grupa…

Nego, kad ih već volimo…možemo si iz fore zadavati zadačiće :slight_smile:

Za početak jedan lagani: Kako bi selektirao Google Map API key, pod uvjetom da znaš da se sastoji od 40 karaktera, koji se ne sastoje od nikakvih specijalnih znakova?

P.S. poanta zadataka je da se uvidi jednostavnost izraza i da se nekoga motivira. Uz rješenje zadatka je ok da se priloži i objašnjenje što koji dio izraza radi.

Ne volim ih i ne volim kad ih netko koristi. Nisam neki strucnjak za regexe i ne koristim ih svakodnevno, ne znam ni kad sam ih zadnji put koristio. Uvijek i svima savjetujem da ih izbjegavaju koliko god je to moguce i da budem iskren u zadnjih 15 godina ne znam da li sam ih koristio sveukupno 10 puta i to sam punoo rekao. Regex je “skup” alat i treba ga izbjegavati 100% i kad god se to moze, a osim sto je skup alat totalno je i necitljiv.

3 Likes

Ja ih koristim svakodnevno, evo sad cu ici nesto popravljat i koristit cu regex da izvadi url i link na sliku.

@bozoou
nemam pojma, ja sam vise vizualni tip, moram vidjet i onda mogu napravit. Mislim imam ovak u glavi ideju kako to sloziti ali to mi vise dodje kao zadatak u skoli nego nesto sto bi se moglo primjeniti.

100% potpis za ne-koristenje.

Jos bih dodao poznati citat:

Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems.

2 Likes

Upamtio sam nekad davno da su skupi i uglavnom ako ih koristim to je neki kratež u .htaccess fajlu.
Oni mu dodju nešto k’o esperanto prog. jezika.

1 Like

Ma dajte, regularni izrazi su najveće zlato. Otvaraju ruke za rješiti probleme koji su bez njih nerješivi. Drugim riječima, problemi koji se bez regularnog izraza fakat muka Isusova (Znači sati i sati posla), s njima se mogu rješiti onako za tri minute posla. :slight_smile: To bi bila neka usporedba što se propušta sa njima.
Vrlo vjerovatno tko ne barata njima, nema ni otvorenu percepciju da je nešto uopće moguće rješiti.
A ne samo da je moguće…nego i relativno lako moguće.

Što se tiče nedostataka:

To što je regex procesorski zahtjevan proces ne dolazi do izražaja ako radimo nešto sa stringom koji je tipa 100 karaktera. Pogotovo ako je to još neka operacija na clientovom računalu…sasvim je nebitno oće li otići na to 0.1ms procesora ili 3ms procesora.
Tako da on itekako pronalazi svoju primjenu tamo gdje nema baš nikakve potrebe diskutirati o tome koliko je on procesorski “skup”.
A naravno da nećemo sa njime pretumbavati po bazi…kao što je @jorgovan dobro napomenuo.
Također, npr. operacije kompajliranja koje se rade jednom prije produkcije…tamo je također sasvim nebitno ako se upotrebio regex. Štoviše, ne mogu zamisliti kompajler koji bi radio bez regularnih izraza…

Nečitljiv? Hmm. Sto posto je više nečitljiv klasičan code od regularnog izraza, ako rade isti zadatak.
Recimo, regularni izraz koji dohvaća Google Map key, na način da predviđa da je to skup znakovnih karaktera dužine 40, bi išao ovako:

\W\w{40}\W

Sada ti napiši klasičan code koji će unutar nekog stringa dohvatiti samo one djelove koji su dužine 40 karaktera, i gdje se ti djelovi sastoje samo od znakova: a-z & A-Z ?
Tvoj kod jako teško može biti čitljiviji od ovoga gore.
A ako se osvrnemo i na skupoću kojiu si spomenuo, teško da ćeš napisati i optmiziraniji code.

Nadalje, ako radiš unutar nekog editra …i imaš potrebu nešto selektirati ili replace-ati unutar source-code-a projekta…onda je spas Božji da se regularni izraz može danas kucati i direktno u konzolu većine editora. U suprotnom, sa svojim source-code-om ćeš to postići puno teže. I tu se opet vidi da skupoća selektiranja sa regularnim izrazima nekada uopće nije bitna.

Dodatno što se tiče nepreglednosti. Regex zaista može pobjeći u nepreglednost, ali to nije bitno iz još jednog razloga:
-dovoljno je pored regularnog izraza staviti opisni komentar što izraz radi.

  • tako da onaj koji čita regularni izraz, sve mu je jasno iz tog komentara
  • a ako zatreba nadogradnja regex izraza, Bože moj…potpuno novi se napiše za 5min. Kad se jednom shvati kako se pišu, možeš svaki puta novog napisati iz glave…nije ni potrebno gledati u postojeći i njega nastojati promjeniti. Glavno je da se iz okoline code-a zna što na tom mjestu regex treba raditi i da se po toj uputi regex i napiše.

Btw. objašnjenje gornjeg izraza:

\ - to je instrukcija da nakon backslasha dolazi karakter instrukcije.

Znači: W je obični karakter, dok je \W instrukcija. Regex i nema tako puno instrukcija, koje kada se nauče…dalje ide sve samo od sebe. Slično kao u programiranju, kada se nauče if, else, for, while, etc.…dalje iz tih relativno malo naredbi, se mogu praviti cijela čuda.

Osim instrukcija koje dolaze nakon \ , postoje karakteri koji su instrukcije i bez da su označeni backslashom. To su npr: ()?$.*+ …ima ih sigurno još, ali to su valjda najčešći.
Može biti i malo tricky, npr karakter { ili } nije instrukcija, ali skup karaktera: {1} čine instrukciju. I ta instrukcija postoji u gornjem izrazu, samo je sa drugim brojem: {40}

\W - ta instrukcija kaže da se selektira karakter koji nije “word” karakter
\w - to je inverzna instrukcija gornjoj i kaže da se selektira karakter koji jeste “word” karakter.

I znamo skoro sve, gornji izraz kaže:

Selektiraj karakter koji nije “word” karakter, zatim selektiraj 40 karaktera koji jesu “word” karakteri i nakon toga opet selektiraj karakter koji nije “word” karakter.

Naravno, selekt će se izvršiti samo ako postoji dio stringa koji ispunjava zadani select.

Izraz koji bi npr glasio:
\w{40}
.taj bi isto selektirao “word” karakter niz dužine 40 karaktera, ali ga nebi smetalo ako se taj niz nalazi tek kao dio nekog dužeg niza

Izraz npr:

ma\wica

-će selektirati i marica i majica i matica, a neće selektirati ma1ca.
Tako da iz toga jednostavnog primjera se lijepo vidi kako se specijalne instrukcije kombiniraju sa običnim karakterima. U suštini, ako se regularni izraz napiše bez specijalnih instrukcija, on će selektirati točno ono što je napisano. A specijalne instrukcije nam daju nezamislivu fleksibilnost prilikom selektiranja, a da ne napišemo niti jedan for / if / else.

Sretno s izrazima. Još jednom najtoplija preporuka. Nevjerovatno je da su to mnogi preskočili.

Nastavno na \w i \W ovo je popis svih selektora tog tipa. Prvo oni koji su česti/bitni:

. (točka) - Find a single character, except newline or line terminator
\w - Find a word character
\W - Find a non-word character
\d - Find a digit
\D - Find a non-digit character
\s - Find a whitespace character
\S - Find a non-whitespace character
\b - Find a match at the beginning/end of a word
\B - Find a match not at the beginning/end of a word
\n - Find a new line character
\t - Find a tab character

//te oni malo manje bitni:

\0 - Find a NUL character
\f - Find a form feed character
\r - Find a carriage return character
\v - Find a vertical tab character
\xxx - Find the character specified by an octal number xxx
\xdd - Find the character specified by a hexadecimal number dd
\uxxxx - Find the Unicode character specified by a hexadecimal number xxxx

Evo još malo korisnih instrukcija, jako jako bitnih! Ovo su nešto drugačijeg tipa instrukcije od gornjih selektora:

n+ - Matches any string that contains at least one n
n* - Matches any string that contains zero or more occurrences of n
n? - Matches any string that contains zero or one occurrences of n
n{X} - Matches any string that contains a sequence of X n’s

Sada sljedeći zadatkić:
koristeći gornje instrukcije, napisati izraz koji će selektirati sve riječi u nekom tekstu?

P.S. da vas ne zbuni u zadatku “sve riječi”, dovoljno je napisati regularni izraz koji selektira riječ, to automatski znači da upotreba tog izraza nad nekim stringom, da on može selektirati sve riječi u tom stringu!

Korisim ih samo kada je to potrebno - u zadnje vrijeme vecinom za neke custom validacije unutar forme i bash skripte.

Daleko sam od eksperta, vecinom je to pokusaj raznih kombinacija dok ne dodjem do zeljenog rezultata :smiley:

1 Like

regex je super kad se pravilno koristi, tj. kad se koristi na pravilnom mjestu.
Problem je sto se ili ne koriste uopce kad bi trebalo ili se koriste pretjerano za stvari koje se ne parsaju regexom.
Definitivno nesto sto svaki programer treba znati, ali ne pretjerivati…

1 Like

Zadatak je pretežak? (A jako je trivijalan zapavo)
…ili nitko nema volje dobiti besplatnu pomoć da svlada prvi korak ka regexima?

Pitanje se ne odnosi na one koji znaju regularne i ne žele spojlati rješenje. Mada, pozvani su i oni da napišu da znaju odgovor…zašto ne.

A oni koji su voljni naučiti, slobodni su lupetati i pitati za hintove? Bit će mi drago sugestije vraćati.
Ako nema voljnih učiti i uzeti djaba pomoć…no problems. :slight_smile: Na vašu štetu kako bi se reklo…

P.S. mislim da sam dao sve potrebno gore da se zadatak riješi…ali moguće naravno da nisam.
Tako da pitajte što fali.
Regexi su zaebani samo u prvom koraku da se shvati ideja slaganja izraza…čim to sjedne, dalje idu ko piti vodu za nekih 90% slučaja gdje trebaju. Tek onih 10% naleti zaista nešto kompleksnije što treba i znanje i kliker za rješiti. Ali hvala Bogu, postoji Google i takvi regexi se lako izguglaju, jer su vjerovatno nekome već trebali. Tipa regex koji hvata zagradu zatvaranja i pazi na ugnježdene zagrade…bome je tricky smrad, ne kužim ga ni kada gledam u rješenje, hehe.

Možda da pojasnim još jednom ova pravila:

n+ - Matches any string that contains at least one n
n* - Matches any string that contains zero or more occurrences of n
n? - Matches any string that contains zero or one occurrences of n
n{X} - Matches any string that contains a sequence of X n’s

“n” se ovdje odnosi na bilo koji karater koji želimo selektirati.
Npr, selektor:
a+ -> selektirat će u tekstu gdje god se pojavljuje slovo “a”. A ako ih se pojavluje više u nizu, slektor će obuhvatiti cijeli niz. Tipa, selektirano će biti boldano:

“Nisaaaaaam ti tako rekao”

Dalje, selektor:

ivana* -> sada ovaj * znači da a može i ne mora postojati u selektoru, selektirano će biti boldano:

Hej ivan, gdje ti je ivana? Ivanaaaaaaaaa.

Npr. selektor:

ivan\w* -> selektira sve što počinje sa ivan… i pošto je \w selektor slova, selektirat će bilo koja slova u nastavku riječi ivan:

Hej ivan, ivanko, kako ti je ivančica?

Dok, selektor:

ivan\w+ -> neće selektirati riječ ivan, jer instrukcija + zahtjeva da postoji barem jedno slovo u nastavku te riječi:

Hej ivan, ivanko, kako ti je ivančica?

I još upitnik, kada smo već tu, selektor:
ivana? -> selektira u tekstu:

Hej ivan , gdje ti je ivana ? Ivanaaaaaa .
…znači a se može i ne mora pojaviti, ali neće uzeti cijeli niz slova a ako ga bude, kao što je u riječi Ivanaaaaaa.

Možda je zadatak sada nijansu svjetliji…pa da idemo na teže :slight_smile:


Copyright © 2020 WM Forum - AboutContact - Sponsored by: Mydataknox & Profit Monkey