A webfejlesztésben, különösen PHP környezetben, nap mint nap találkozunk szöveges adatokkal: űrlapok bemenetei, URL-ek, e-mail címek, log fájlok, adatbázis bejegyzések. Ezek feldolgozása, ellenőrzése és manipulálása kulcsfontosságú a robusztus és biztonságos alkalmazások építéséhez. Ebben a feladatban a reguláris kifejezések, vagy röviden regexek, a fejlesztő egyik legerősebb fegyverévé válnak. Ez a cikk célja, hogy átfogó útmutatót nyújtson a PHP és a reguláris kifejezések hatékony használatához, bemutatva alapjaikat, a PHP függvényeit, gyakorlati alkalmazásokat és a teljesítményoptimalizálás szempontjait.
Mi is az a Reguláris Kifejezés?
A reguláris kifejezés egy minta, amely egy karakterláncban keresendő karaktersorozatot ír le. Gondoljunk rá úgy, mint egy rugalmas és erőteljes „keresés és illesztés” nyelvre. Képesek vagyunk vele ellenőrizni, hogy egy string tartalmaz-e egy adott mintát, kivonni részeket belőle, vagy akár helyettesíteni bizonyos mintázatokat. Míg a PHP beépített string függvényei (pl. strpos(), substr()) kiválóan alkalmasak egyszerűbb műveletekre, addig a komplexebb, változatos minták felismerésére a regexek nyújtanak megoldást. A PHP Perl-kompatibilis reguláris kifejezéseket (PCRE) használ, ami rendkívül gazdag funkcionalitást és robusztusságot biztosít.
A Reguláris Kifejezések Alapjai: Szintaxis és Metakarakterek
Ahhoz, hogy hatékonyan használhassuk a regexeket, meg kell értenünk az alapvető építőköveket.
Literális karakterek
A legtöbb karakter önmagát jelenti. Például a /alma/ minta az „alma” szót keresi. Ha speciális karaktert (metakaraktert) szeretnénk literálisként használni, azt backslash-sel () kell escapelni. Pl.: a /./ a pont karaktert jelenti, nem pedig bármilyen karaktert.
Metakarakterek és jelentésük
.(pont): Bármely karaktert jelenti, kivéve az új sor karaktert (alapértelmezetten).*(csillag): Az előtte álló elem nulla vagy több előfordulását jelenti. Pl.:/ab*c/illeszkedik az „ac”, „abc”, „abbc” stringekre.+(plusz): Az előtte álló elem egy vagy több előfordulását jelenti. Pl.:/ab+c/illeszkedik az „abc”, „abbc” stringekre, de nem az „ac”-re.?(kérdőjel): Az előtte álló elem nulla vagy egy előfordulását jelenti (opcionális). Pl.:/colou?r/illeszkedik a „color” és „colour” szavakra.[](karakterosztály): A szögletes zárójelekben felsorolt karakterek közül bármelyikre illeszkedik. Pl.:/[aeiou]/bármely magánhangzóra illeszkedik. Tartományok is megadhatók:/[a-z]/,/[0-9]/. A^jellel negálhatjuk a karakterosztályt:/[^0-9]/bármely nem számjegyre illeszkedik.()(csoportosítás): Összefog egy mintát, és lehetővé teszi a részminták kivonását (capturing group). Pl.:/(felhasználó)s(név)/.|(vagy): Alternatívákat ad meg. Pl.:/kutya|macska/illeszkedik a „kutya” vagy „macska” szavakra.{}(kvantifikátorok): Meghatározott számú előfordulást ad meg.{n}: Pontosan n előfordulás. Pl.:/d{3}/három számjegyre illeszkedik.{n,}: Legalább n előfordulás. Pl.:/d{3,}/legalább három számjegyre illeszkedik.{n,m}: Legalább n, de legfeljebb m előfordulás. Pl.:/d{3,5}/három, négy vagy öt számjegyre illeszkedik.
Speciális karakterosztályok
d: Bármely számjegy (0-9). Egyenlő[0-9]-vel.D: Bármely nem számjegy. Egyenlő[^0-9]-vel.w: Bármely szókarakter (betű, számjegy vagy aláhúzás). Egyenlő[a-zA-Z0-9_]-vel.W: Bármely nem szókarakter. Egyenlő[^a-zA-Z0-9_]-vel.s: Bármely whitespace karakter (szóköz, tab, új sor).S: Bármely nem whitespace karakter.
Pozíciók és határok
^: A string elejére illeszkedik.$: A string végére illeszkedik.b: Szóhatárra illeszkedik. Pl.:/bcatb/csak a „cat” szóra illeszkedik, nem a „catalog”-ra.B: Nem szóhatárra illeszkedik.
PHP Reguláris Kifejezés Függvényei (PCRE)
A PHP egy sor preg_ prefixű funkciót kínál a PCRE használatához. Ezek a függvények rendkívül sokoldalúak és a legtöbb szövegfeldolgozási feladathoz elegendőek.
preg_match(): Az első találat
Ez a függvény megkeresi az első illeszkedést egy stringben. Ha talál illeszkedést, 1-et ad vissza, ellenkező esetben 0-át. Az illeszkedéseket egy opcionális harmadik paraméterbe (egy tömbbe) gyűjti.
<?php
$szoveg = "A macska eszik, a kutya alszik.";
$minta = "/macska/";
if (preg_match($minta, $szoveg, $talalatok)) {
echo "Találat: " . $talalatok[0] . "<br>"; // Kiírja: Találat: macska
} else {
echo "Nincs találat.<br>";
}
// Csoportosítás használata
$email = "[email protected]";
$email_minta = "/^([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+.[a-zA-Z]{2,})$/";
if (preg_match($email_minta, $email, $reszek)) {
echo "Felhasználónév: " . $reszek[1] . "<br>"; // kontakt
echo "Domain: " . $reszek[2] . "<br>"; // pelda.hu
}
?>preg_match_all(): Az összes találat
Ha az összes illeszkedést szeretnénk megtalálni egy stringben, a preg_match_all() a megfelelő választás. Visszaadja az illeszkedések számát, és az összes találatot egy tömbbe gyűjti.
<?php
$szoveg = "alma, körte, banán, szilva";
$minta = "/(bw+b)/"; // Minden szó megtalálása
preg_match_all($minta, $szoveg, $talalatok, PREG_PATTERN_ORDER);
echo "<h3>Az összes gyümölcs:</h3><ul>";
foreach ($talalatok[0] as $gyumolcs) {
echo "<li>" . $gyumolcs . "</li>";
}
echo "</ul>";
?>Megjegyzés: A PREG_PATTERN_ORDER paraméter azt jelenti, hogy a találatok a mintában szereplő csoportok sorrendjében kerülnek rendezésre. A PREG_SET_ORDER minden egyes teljes találatot egy külön tömbként tárolna, beleértve a csoportokat is.
preg_replace(): Illeszkedő minták cseréje
Ez a függvény lehetővé teszi, hogy egy reguláris kifejezés által talált mintákat egy adott stringgel cseréljük ki. Rendkívül hasznos stringek tisztítására, formázására vagy bizonyos részek eltávolítására.
<?php
$szoveg = "A kutya ugat. A macska nyávog. A madár csicsereg.";
$minta = "/(kutya|macska|madár)/";
$csere = "<strong>$1</strong>"; // $1 hivatkozik a csoport által talált értékre
$uj_szoveg = preg_replace($minta, $csere, $szoveg);
echo $uj_szoveg; // A <strong>kutya</strong> ugat. A <strong>macska</strong> nyávog. A <strong>madár</strong> csicsereg.
// HTML tag-ek eltávolítása (figyelem, ez nem robustus HTML parsolásra!)
$html = "<p>Ez egy <b>HTML</b> string.</p>";
$tiszta_szoveg = preg_replace("/<[^>]+>/", "", $html);
echo "<br>" . $tiszta_szoveg; // Ez egy HTML string.
?>preg_split(): Stringek felosztása regex alapján
A preg_split() a explode() regex megfelelője. Egy reguláris kifejezés által meghatározott elválasztó mentén bontja fel a stringet egy tömbre.
<?php
$lista = "egy, ketto;harom | negy";
$elvalaszto = "/[;,|]s*/"; // vessző, pontosvessző vagy pipe és opcionális szóköz
$elemek = preg_split($elvalaszto, $lista);
print_r($elemek);
/* Kimenet:
Array
(
[0] => egy
[1] => ketto
[2] => harom
[3] => negy
)
*/
?>preg_grep() és preg_filter(): Tömbök szűrése és módosítása
A preg_grep() egy tömb elemeit szűri egy reguláris kifejezés alapján, és csak az illeszkedő elemeket tartalmazó új tömböt adja vissza.
A preg_filter() hasonló a preg_replace()-hez, de tömbökkel működik. Csak azokat az elemeket adja vissza, amelyek illeszkedtek, és rajtuk végrehajtja a cserét. Ha egy elem illeszkedik, de a csereüres, akkor az elem eltűnik a visszaadott tömbből.
<?php
$url_lista = [
"http://www.pelda.hu",
"https://biztos.com",
"ftp://fajlserver.org",
"www.masik.net"
];
$http_minta = "/^https?:///"; // illeszkedik http:// vagy https:// kezdetre
$http_url_ek = preg_grep($http_minta, $url_lista);
print_r($http_url_ek);
/* Kimenet:
Array
(
[0] => http://www.pelda.hu
[1] => https://biztos.com
)
*/
// Domainek kinyerése
$domain_minta = "/^https?://(.+)/";
$domain_csere = "$1"; // Csak a csoport által talált rész
$domain_ek = preg_filter($domain_minta, $domain_csere, $url_lista);
print_r($domain_ek);
/* Kimenet:
Array
(
[0] => www.pelda.hu
[1] => biztos.com
)
*/
?>Elválasztók és Módosítók
A reguláris kifejezések mintáit elválasztók közé kell tenni a PHP-ben. Gyakori elválasztók a /, #, ~. Fontos, hogy az elválasztó ne szerepeljen a mintában, hacsak nem escapeljük.
A minta után, az elválasztó záró karaktere után adhatók meg a módosítók, amelyek megváltoztatják a minta viselkedését:
i(case-insensitive): Kis- és nagybetűket figyelmen kívül hagyja. Pl.:/alma/iilleszkedik az „Alma”, „ALMA” szavakra.m(multiline): A^és$metakarakterek nem csak a string elejére/végére, hanem minden sor elejére/végére is illeszkednek.s(dotall): A.metakarakter illeszkedik az új sor (n) karakterre is.U(ungreedy/lusty): A kvantifikátorok (*,+,?,{}) alapértelmezetten mohók (greedy), azaz a lehető leghosszabb illeszkedést találják meg. AzUmódosító lustává teszi őket, a lehető legrövidebbet keresik. Egyedileg is megadható a?utótaggal: pl..*?.x(extended): A mintán belüli whitespace karaktereket figyelmen kívül hagyja (kivéve, ha escapelve vannak), és lehetővé teszi kommentek használatát (#jellel). Ez javítja a komplex minták olvashatóságát.
<?php
$szoveg = "Hello World";
$minta_i = "/hello world/i"; // case-insensitive illeszkedés
preg_match($minta_i, $szoveg, $talalat); // találat lesz
$komplex_minta = "/
^(w+) # Felhasználónév
@ # kukac jel
([w.]+) # Domain név
. # pont
([a-z]{2,3}) # TLD
$/ix"; // x a kommentekért, i a case-insensitive-ért
?>Gyakorlati Alkalmazások és Példák
A reguláris kifejezések ereje igazán a gyakorlati példákban mutatkozik meg.
E-mail cím validálás
Az egyik leggyakoribb feladat. Bár a regexekkel lehet validálni e-mail címeket, fontos megjegyezni, hogy az RFC-szabványok teljes körű lefedése rendkívül komplex mintát eredményezne. Gyakorlati célokra azonban egy egyszerűbb minta elegendő.
<?php
function is_valid_email(string $email): bool {
// Alapvető validálási minta. Nem 100% RFC-kompatibilis, de a legtöbb esetet lefedi.
$minta = "/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$/";
return (bool) preg_match($minta, $email);
}
echo is_valid_email("[email protected]") ? "Érvényes" : "Érvénytelen"; // Érvényes
echo "<br>";
echo is_valid_email("rossz-email") ? "Érvényes" : "Érvénytelen"; // Érvénytelen
?>**Megjegyzés:** PHP 5.2.0-tól elérhető a filter_var($email, FILTER_VALIDATE_EMAIL) funkció, ami sokszor preferáltabb, mivel a PHP karbantartja és jobban kezeli az edge case-eket.
URL validálás és komponensek kinyerése
<?php
$url = "https://www.google.com/search?q=php+regex#top";
$minta = "#^(https?|ftp)://([a-zA-Z0-9.-]+)(:d+)?(/[^?]*)?(?[^#]*)?(#.*)?$#";
if (preg_match($minta, $url, $reszek)) {
echo "Protokoll: " . $reszek[1] . "<br>"; // https
echo "Host: " . $reszek[2] . "<br>"; // www.google.com
echo "Útvonal: " . $reszek[4] . "<br>"; // /search
echo "Query: " . $reszek[5] . "<br>"; // ?q=php+regex
echo "Fragment: " . $reszek[6] . "<br>"; // #top
}
?>Megjegyzés: URL-ek parsolására létezik a parse_url() függvény, ami a legtöbb esetben szintén előnyösebb.
Telefonszám formázás/validálás
<?php
$telefon = " +36 20-123 4567 ";
$minta = "/[^0-9+]/"; // Minden nem számjegy és nem + karakter
$tiszta_telefon = preg_replace($minta, "", $telefon);
echo "Tisztított: " . $tiszta_telefon . "<br>"; // +36201234567
// Validálás (egyszerű példa magyar számokra)
$valid_minta = "/^+36d{9}$/";
echo preg_match($valid_minta, $tiszta_telefon) ? "Érvényes magyar szám" : "Érvénytelen";
?>XSS támadások megelőzése (korlátozottan)
Bár a regexek segíthetnek bizonyos veszélyes minták kiszűrésében, sosem szabad kizárólag rájuk hagyatkozni biztonsági célból! Mindig használjuk a PHP beépített funkcióit, mint például a htmlspecialchars() vagy a strip_tags(), és a megfelelő kimeneti szűrést.
<?php
$input = "<script>alert('XSS');</script>Ez egy <b>biztonságos</b> szöveg.";
$minta = "/<script.*?</script>/is"; // Eltávolítja a script tageket
$tiszta_input = preg_replace($minta, "", $input);
echo htmlspecialchars($tiszta_input); // Veszélyes elemek nélkül, HTML-entities kódolva.
?>Teljesítményre vonatkozó Megfontolások
A reguláris kifejezések hihetetlenül hatékonyak lehetnek, de a rosszul megírt minták komoly teljesítményproblémákat, akár ReDoS (Regular Expression Denial of Service) támadásokat is okozhatnak.
Regex vs. string függvények
Mindig gondoljuk át, hogy valóban szükség van-e regexre. Egyszerű string keresésekhez (pl. egy szó létezésének ellenőrzése, egy string részének kinyerése rögzített pozícióból) a PHP beépített string függvényei (strpos(), substr(), str_replace()) gyakran sokkal gyorsabbak, mivel nem kell értelmezniük egy komplex mintát.
Mohó (Greedy) vs. Lusta (Lazy/Ungreedy) kvantifikátorok
Alapértelmezetten a kvantifikátorok (*, +, {m,n}) mohók. Ez azt jelenti, hogy a lehető leghosszabb illeszkedést próbálják megtalálni. Ha ez nem az, amit szeretnénk, vagy ha a minta túl sok lehetőséget vizsgál feleslegesen, lustává tehetjük őket egy ? hozzáfűzésével (pl. .*?, .+?, .{m,n}?). Ez jelentősen javíthatja a teljesítményt.
<?php
$szoveg = "<b>Első</b> és <b>Második</b> kiemelt szöveg.";
// Mohó (greedy) - rossz
$minta_greedy = "/<b>.*</b>/";
preg_match($minta_greedy, $szoveg, $talalat);
echo "Greedy: " . $talalat[0] . "<br>"; // <b>Első</b> és <b>Második</b>
// Lusta (lazy/ungreedy) - jó
$minta_lazy = "/<b>.*?</b>/";
preg_match($minta_lazy, $szoveg, $talalat);
echo "Lazy: " . $talalat[0] . "<br>"; // <b>Első</b>
preg_match_all($minta_lazy, $szoveg, $talalatok_lazy);
echo "Lazy (összes): " . implode(", ", $talalatok_lazy[0]) . "<br>"; // <b>Első</b>, <b>Második</b>
?>Katasztrófális visszalépés (Catastrophic Backtracking)
Ez egy súlyos teljesítményprobléma, amikor egy rosszul megírt regex (gyakran egymásba ágyazott vagy opcionális kvantifikátorokkal) exponenciálisan növekvő számú lehetséges illeszkedést próbál meg, ami lefagyhatja az alkalmazást. Például: (a+)+b. Kerüljük az ilyen mintázatokat.
Optimalizált minták
- Legyünk minél specifikusabbak a mintáinkban. Például a
d+gyorsabb, mint a.*ha számokat keresünk. - Használjunk horgonyokat (
^,$) ha a string elejére/végére való illeszkedésről van szó, mivel ez gyorsabbá teheti a keresést. - Kerüljük a szükségtelen csoportosításokat. A nem rögzítő csoportok (non-capturing groups)
(?:...)egy kicsit hatékonyabbak, ha nincs szükség a tartalom kivonására.
Gyakori Hibák és Best Practice-ek
- HTML parsolása regex-szel: Gyakori hiba, hogy HTML-t próbálnak regex-szel parsolni. A HTML egy hierarchikus, nem reguláris nyelv, ezért a regexekkel történő parsolása szinte mindig hibás eredményre vezet, és rendkívül törékeny. Használjunk dedikált DOM parsert (pl. PHP
DOMDocument). - Biztonsági kockázatok: A reguláris kifejezések rossz használata biztonsági réseket okozhat (lásd ReDoS). Mindig teszteljük a mintákat, és sose bízzunk a felhasználói bemenetben, ha az befolyásolhatja a regex mintázatot.
- Tesztelés: Használjunk online regex tesztelőket (pl. regex101.com, regexr.com) a mintáink ellenőrzésére és hibakeresésére. Írjunk unit teszteket is.
- Olvashatóság: A komplex regexek gyorsan olvashatatlanná válhatnak. Használjuk az
xmódosítót és kommenteljük a mintákat, vagy bontsuk több lépésre a feladatot. - Hibakezelés: Mindig ellenőrizzük a
preg_függvények visszatérési értékét, és használjuk apreg_last_error()függvényt a hibák azonosítására.
Fejlettebb Fogalmak (Röviden)
- Lookaheads és Lookbehinds: Ezek olyan nulla szélességű állítások, amelyek anélkül ellenőrzik a mintát megelőző vagy követő szöveget, hogy azt az illesztés részévé tennék. Pl.:
/foo(?=bar)/illeszkedik a „foo”-ra, ha azt a „bar” követi. - Atomikus csoportosítás (Atomic Grouping): Megakadályozza a visszalépést egy csoporton belül, ami javíthatja a teljesítményt és a prediktabilitást komplex minták esetén. Pl.:
(?>.*)foo. - Visszahivatkozások (Backreferences): Lehetővé teszik, hogy a mintán belül hivatkozzunk egy korábban rögzített csoport tartalmára. Pl.:
/(['"])w+1/illeszkedik az idézőjelekkel vagy aposztrófokkal határolt szavakra, biztosítva, hogy a nyitó és záró idézőjel megegyezzen.
Összefoglalás
A PHP és a reguláris kifejezések kombinációja rendkívül hatékony eszköztár a szövegfeldolgozáshoz. Megfelelő használatukkal időt takaríthatunk meg, növelhetjük az alkalmazásunk rugalmasságát és pontosságát a különböző adatok kezelése során. Fontos azonban, hogy megértsük az alapokat, tisztában legyünk a PCRE funkcióival, és odafigyeljünk a teljesítményre és a biztonságra. Ne féljünk kísérletezni, tesztelni, és folyamatosan fejleszteni a regex készségeinket, hiszen ez egy olyan tudás, amely minden webfejlesztő eszköztárában elengedhetetlen.
Leave a Reply