Karakterláncok kezelése

A Világháló valójában szöveges fájlokra épülõ környezet, és igazából nem számít,
mivel gazdagodik a jövõben a tartalma, a mélyén mindig szöveges állományokat
fogunk találni. Így nem meglepõ, hogy a PHP 4 sok olyan függvényt biztosít,
amellyel szövegmûveletek végezhetõk.
Az óra során a következõket tanuljuk meg:
• Hogyan formázzunk karakterláncokat?
• Hogyan határozzuk meg a karakterláncok hosszát?
• Hogyan találjunk meg egy karakterláncon belüli karakterláncot?
• Hogyan bontsuk szét a karakterláncot alkotóelemeire?
• Hogyan távolítsuk el a szóközöket a karakterláncok végérõl vagy elejérõl?
• Hogyan cseréljünk le karakterlánc-részleteket?
• Hogyan változtassuk egy karakterláncban a kisbetûket nagybetûre és fordítva?
Karakterláncok formázása
A megjeleníteni kívánt karakterláncot eddig egyszerûen kiírattuk a böngészõbe.
A PHP két olyan függvényt tartalmaz, amely lehetõvé teszi az elõzetes formázást,
függetlenül attól, hogy tizedestörteket kell valahány tizedes pontosságra kerekíteni,
egy mezõn belül kell jobbra vagy balra igazítani valamit, vagy egy számot kell
különbözõ számrendszerekben megjeleníteni. Ebben a részben a printf() és
az sprintf() függvények által biztosított formázási lehetõségekkel ismerkedünk
meg.
A printf() függvény használata
Ha már dolgoztunk C-vel, biztosan ismerõs lesz a printf() függvény, amelynek
PHP-s változata hasonló, de nem azonos azzal. A függvény bemenete egy karakterl
ánc, más néven a formátumvezérlõ karakterlánc (röviden formázó karakterlánc
vagy egyszerûen formázó), emellett további, különbözõ típusú paraméterek.
A formázó karakterlánc ezen további paraméterek megjelenítését határozza meg.
A következõ kódrészlet például a printf() függvényt használja, hogy egy egész
számot decimális értékként írjon ki:
printf("az én számom az %d", 55 );
// azt írja ki, hogy "az én számom az 55"
A formázó karakterláncban (ami az elsõ paraméter) egy különleges kódot helyezt
ünk el, amely átalakítási meghatározásként ismert.
Az átalakítási meghatározás százalékjellel (%) kezdõdik, és azt határozza
meg, hogyan kell a printf() függvény neki megfelelõ paraméterét
kezelni. Egyetlen formátumvezérlõ karakterláncba annyi átalakítási meghatározást
írhatunk, amennyit csak akarunk, feltéve, hogy a printf() függvénynek ugyanennyi
paramétert adunk át a formázót követõen.
A következõ kódrészlet két számot ír ki a printf() használatával:
printf("Az elsõ szám: %d
\nA második szám: %d
\n",
55, 66 );
// A kiírt szöveg:
// Az elsõ szám: 55
// A második szám: 66
Az elsõ átalakítási meghatározás a printf() második paraméterének felel meg,
ami ebben az esetben az 55. A következõ átalakítási meghatározás a 66-nak felel
meg. A százalékjelet követõ d betû miatt a függvény az adatot decimális egészként
értelmezi. A meghatározásnak ez a része típusparaméterként ismeretes.
ÚJDONSÁG
320 17. óra
A printf() és a típusparaméterek
Egy típusparaméterrel már találkoztunk, ez volt a d, amely az adatot decimális
formátumban jeleníti meg. A többi típusparamétert a 17.1. táblázatban láthatjuk.
17.1. táblázat Típusparaméterek
Paraméter Leírás
d A paramétert decimális számként jeleníti meg.
b Egész számokat bináris számként jelenít meg.
c Egy egész számot annak ASCII megfelelõjeként jelenít meg.
f A paramétert lebegõpontos számként ábrázolja.
o Egy egész számot oktális (8-as számrendszerû) számként
jelenít meg.
s A paramétert karakterlánc-állandónak tekinti.
x Egy egész számot kisbetûs hexadecimális (16-os számrendszer
û) számként jelenít meg.
X Egy egész számot nagybetûs hexadecimális (16-os számrendszer
û) számként jelenít meg
A 17.1. program a printf() függvénnyel egy számot a 17.1. táblázat típusparam
éterei segítségével jelenít meg.
Vegyük észre, hogy a formázó karakterlánc nem egyszerûen csak átalakítási
meghatározásokat tartalmaz, minden további benne szereplõ szöveg kiírásra kerül.
17.1. program Néhány típusparaméter használatának bemutatása
1:
2:
3:
4:
5:
6: 7: $szam = 543;
8: printf("Decimális: %d
", $szam );
9: printf("Bináris: %b
", $szam );
Karakterláncok kezelése 321
17
17.1. program (folytatás)
10: printf("Kétszeres pontosságú: %f
", $szam );
11: printf("Oktális: %o
", $szam );
12: printf("Karakterlánc: %s
", $szam );
13: printf("Hexa (kisbetûs): %x
", $szam );
14: printf("Hexa (nagybetûs): %X
", $szam );
15: ?>
16:
17:
A 17.1. program kimenetét a 17.1. ábrán láthatjuk. A printf() függvénnyel
gyorsan tudunk adatokat egyik számrendszerbõl a másikba átalakítani és az eredm
ényt megjeleníteni.
Ha a HTML-ben hivatkoznunk kell egy színre, három 00 és FF közé esõ, a vörös,
zöld és kék színt képviselõ hexadecimális számot kell megadnunk. A printf()
függvényt használhatjuk arra, hogy a három 0 és 255 közé esõ decimális számot
azok hexadecimális megfelelõire alakítsuk át:
$piros = 204;
$zold = 204;
$kek = 204;
printf( "#%X%X%X", $piros, $zold, $kek );
// azt írja ki, hogy "#CCCCCC"
322 17. óra
17.1. ábra
Néhány típusparamé-
ter használatának
bemutatása
Bár a típusparaméterrel a decimális számokat hexadecimálissá alakíthatjuk,
azt nem tudjuk meghatározni, hogy az egyes paraméterek kimenete hány karaktert
foglaljon el. A HTML színkódjában minden hexadecimális számot két karakteresre
kell kitölteni, ami problémát okoz, ha például az elõzõ kódrészlet $piros,
$zold, $kek változóit úgy módosítjuk, hogy 1-et tartalmazzanak. Kimenetül
"#111"-et kapnánk. A bevezetõ nullák használatát egy kitöltõ paraméter segítsé-
gével biztosíthatjuk.
A kitöltõ paraméter
Beállíthatjuk, hogy a kimenet bizonyos karakterekkel megfelelõ szélességûre
töltõdjön ki. A kitöltõ paraméter közvetlenül az átalakító paramétert kezdõ százal
ékjelet követi. Ha a kimenetet bevezetõ nullákkal szeretnénk kitölteni, a kitöltõ
paraméterben a 0 karaktert az a szám követi, ahány karakteresre szeretnénk
a kimenetet bõvíteni. Ha a kimenet hossza ennél a számnál kisebb lenne, a különbs
ég nullákkal kerül kitöltésre, ha nagyobb, a kitöltõ paraméternek nincs hatása:
printf( "%04d", 36 )
// a kimenet "0036" lesz
printf( "%04d", 12345 )
// a kimenet "12345" lesz
Ha a kimenetet bevezetõ szóközökkel szeretnénk kitölteni, a kitöltõ paraméternek
tartalmaznia kell egy szóköz karaktert, amelyet a kimenet elvárt karakterszáma
követ:
printf( "% 4d", 36 )
// azt írja ki, hogy " 36"
Karakterláncok kezelése 323
17
Ha szóközön vagy nullán kívül más karaktert szeretnénk a kitöltéshez használni,
a kitöltõ paraméteren belül a kitöltõ karakter elé írjunk egyszeres idézõjelet:
printf( "%'x4d", 36 )
// azt írja ki "xx36"
Most már rendelkezésünkre állnak azok az eszközök, melyekkel a korábbi HTML
kódot kiegészíthetjük. Eddig ugyan már át tudtuk alakítani a három számot,
de nem tudtuk bevezetõ nullákkal kitölteni azokat:
$piros = 1;
$zold = 1;
$kek = 1;
printf( "#%02X%02X%02X", $piros, $zold, $kek );
// azt írja ki, hogy "#010101"
Most már minden változó hexadecimális számként fog megjelenni. Ha a kimenet
két karakternél rövidebb, a hiányt bevezetõ nullák pótolják.
324 17. óra
Bár a HTML dokumentumokban egymás után szereplõ több
szóközt a böngészõk nem jelenítik meg, a megjelenítendõ szö-
veg elé és után helyezett

 címkével mégis biztosíthatjuk
a szóközök és sortörések megjelenítését.

print "A szóközök láthatóvá válnak."
?>

Ha teljes dokumentumot szeretnénk szövegként megformázni,
a header() függvényt használhatjuk a dokumentumtípus
(Content-Type) fejlécének módosításához.
header("Content-type: text/plain");
Ne feledjük, hogy programunk nem küldhet semmilyen kimenetet
a böngészõnek a header() függvényhívást megelõzõen, hogy
a megfelelõ módon mûködjön, mivel a kimenet megkezdésekor
a válasz fejrészét már elküldtük a böngészõnek.
A mezõszélesség meghatározása
Meghatározhatjuk a kimenet által elfoglalt mezõ szélességét is. A mezõszélesség
paramétere egy olyan egész szám, amely a százalékjel után következik az átalakító
paraméterben (feltéve, hogy nem használunk helykitöltõ karaktereket). A következ
õ kódrészlet kimenete egy négyelemû felsorolás, amelynek mezõszélessége
20 karakternyi. A szóközök láthatóvá tételéhez a kimenetet egy PRE elembe
ágyazzuk.
print "
";
printf("%20s\n", "Könyvek");
printf("%20s\n", "CDk");
printf("%20s\n", "Játékok");
printf("%20s\n", "Magazinok");
print "
";
A 17.2. ábrán a fenti kódrészlet eredményét láthatjuk.
A kimenet alapértelmezés szerint a mezõn belül jobbra igazodik. A balra igazítást
a mezõszélesség paramétere elé tett mínuszjellel (-) érhetjük el.
printf ("%-20s|<- eddig tart a balra zárás\n", "Balra zárt");
Fontos megjegyezni, hogy ha lebegõpontos számot írunk ki, az igazítás csak
a kimenetben levõ szám (ponttól jobbra levõ) tizedesrészére vonatkozik.
Más szóval jobbra igazításkor a lebegõpontos számnak a tizedesponttól balra esõ
része a mezõ bal oldali, túlsó végén marad.
Karakterláncok kezelése 325
17
17.2. ábra
Igazítás a mezõszé-
lességhez
A pontosság meghatározása
Ha az adatot lebegõpontos formában szeretnénk megjeleníteni, meghatározhatjuk
a kerekítés pontosságát. Ez fõleg a pénznem átváltásakor szokott fontos lenni.
A pontosságot meghatározó paraméter egy pontból és egy számból áll, és közvetlen
ül a típusparaméter elé kell írni. A megadott szám határozza meg, hány tizedesre
szeretnénk kerekíteni. Ez a paraméter csak akkor érvényes, ha a kimenet
f típusparaméterû:
printf ("%.2f\n", 5.333333);
// azt írja ki, hogy "5.33"
Átalakító paraméterek (Ismétlés)
A 17.2. táblázatban az átalakító paramétereket foglaljuk össze. Megjegyzendõ,
hogy a két (kitöltõ és mezõszélesség) paraméter együttes használata bonyolult,
így azt tanácsoljuk, egyszerre csak az egyiket használjuk.
17.2. táblázat Az átalakítás lépései
Név Leírás Példa
Kitöltõ paraméter A kimenet által elfoglalandó karakter- ' 4'
számot és a kitöltésre használt karaktert
adja meg.
Mezõszélesség paraméter A formázandó karakterlánc méretét '20'
adja meg.
Pontosság paraméter Meghatározza, hogy a kétszeres '.4'
pontosságú számokat hány tizedesre
kell kerekíteni.
Típusparaméter Meghatározza az eredmény adattípusát. 'd'
326 17. óra
A C nyelv printf() függvényében akkor is lehetõségünk van
a pontosság megadására, ha decimális kimenet esetén kérünk
kitöltést. A PHP 4-ben a pontosság paraméterének nincs
semmilyen hatása a decimális kimenetre. Egész számok nullákkal
való bevezetéséhez a kitöltõ paramétert kell használnunk.
A 17.2. program a printf() használatával egy termékárlistát hoz létre.
17.2. program Termékárlista formázása a printf() függvénnyel
1: 
2: 
3: 
4: 
5: 
6: 7: $termekek = Array("Zöld karosszék"=>"222.4",
8: "Gyertyatartó" => "4",
9: "Kávézóasztal" => "80.6"
10: );
11: print "
";
12: printf("%-20s%23s\n", "Név", "Ár");
13: printf("%'-43s\n", "");
14: foreach ( $termekek as $kulcs=>$ertek )
15: printf( "%-20s%20.2f\n", $kulcs, $ertek );
16: print "
";
17: ?>
18: 
19: 
Elõször a termékek nevét és árát tartalmazó tömböt adjuk meg. Egy PRE elemmel
jelezzük a böngészõnek, hogy a szóközöket és a soremeléseket értelmezze.
A printf() elsõ meghívása a következõ formázó karakterláncot adja meg:
"%-20s%23s\n"
Az elsõ átalakító meghatározás ("%-20s") a mezõszélességet balra zárt 20 karakteresre
állítja. Ebben a mezõben egy karakterlánc típusú paramétert helyezünk el.
A második meghatározás ("%23s") egy jobbra zárt mezõszélességet ad meg.
A printf() függvénynek ez a meghívása hozza létre leendõ táblázatunk fejlécét.
A printf() második meghívásával egy 43 karakter hosszú, mínuszjelekbõl (-)
álló vonalat húzunk. Ezt úgy érjük el, hogy egy üres karakterláncot kitöltõ param
éterrel jelenítünk meg.
A printf() legutolsó meghívása annak a foreach utasításnak a része, amely
végiglépked a termékek tömbjén. Két átalakító meghatározást használunk.
Karakterláncok kezelése 327
17
Az elsõ ("%-20s") a termék nevét írja ki egy 20 karakteres mezõbe, balra igazítva.
A másik ("%20.2f") a mezõszélesség paraméterrel azt biztosítja, hogy
az eredmény egy 20 karakteres mezõben jobbra igazítva jelenjen meg, a pontossá-
gi paraméterrel pedig azt, hogy a megjelenített kétszeres pontosságú érték két
tizedesre legyen kerekítve.
A 17.3. ábrán a 17.2. program eredményét láthatjuk.
Formázott karakterlánc tárolása
A printf() az adatokat a böngészõben jeleníti meg, ami azzal jár, hogy eredmé-
nye programunk számára nem elérhetõ. Használhatjuk azonban a sprintf()
függvényt is, amelynek használata megegyezik a printf() függvényével,
viszont az eredményét egy karakterláncban adja vissza, amelyet aztán késõbbi
használatra egy változóba helyezhetünk. A következõ kódrészlet a sprintf()
függvény segítségével egy lebegõpontos értéket két tizedesre kerekít és az eredm
ényt a $kerek változóban tárolja:
$kerek = sprintf("%.2f", 23.34454);
print "Még $kerek forintot költhetsz";
A sprintf() függvény egy lehetséges felhasználása, hogy vele a megformázott
adatot fájlban lehet tárolni. Ennek az a módja, hogy elõször meghívjuk a sprintf()
függvényt, a visszaadott értékét egy változóban tároljuk, majd az fputs() függv
énnyel fájlba írjuk.
328 17. óra
17.3. ábra
Termékárlista formá-
zása a printf() függv
énnyel
Részletesebben a karakterláncokról
Nem minden esetben tudunk mindent azokról az adatokról, amelyekkel dolgozunk.
A karakterláncok többféle forrásból is érkezhetnek, beviheti a felhasználó,
érkezhetnek adatbázisokból, fájlokból és weboldalakról. A PHP 4 több függvénye
segítségünkre lehet abban, hogy ezekrõl a külsõ forrásból érkezõ adatokról többet
tudjunk meg.
Szövegek indexelése
A karakterláncokkal kapcsolatban gyakran használjuk az indexelés szót, de
a tömböknél még gyakrabban találkozhatunk vele. Valójában a karakterláncok és
a tömbök nem állnak olyan messze egymástól, mint azt gondolnánk. Egy karakterl
áncot elképzelhetünk egy karakterekbõl álló tömbként is. Ennek megfelelõen
a karakterláncok egyes karaktereihez ugyanúgy férhetünk hozzá, mint egy tömb
elemeihez:
$proba = "gazfickó";
print $proba[0]; // azt írja ki, hogy "g"
print $proba[2]; // azt írja ki, hogy "z"
Ne felejtsük el, hogy amikor egy karakterláncon belüli karakter indexérõl vagy
helyérõl beszélünk, akkor a karaktereket – ugyanúgy, mint a tömb elemeit – 0-tól
kezdve számozzuk. A tömbökkel kapcsolatos félreértések elkerülése érdekében
a PHP 4 bevezette a $proba{0} formát is erre a célra.
Szöveg hosszának megállapítása az strlen() függvénnyel
Az strlen() függvény segítségével megállapíthatjuk egy karakterlánc hosszát.
A függvény bemenete egy karakterlánc, visszatérési értéke pedig egy egész szám,
amely a függvénynek átadott változó karaktereinek száma. Ez a függvény például
kimondottan jól jöhet a felhasználó által megadott bemenet hosszának ellenõrzé-
sére. A következõ kódrészlettel ellenõrizhetjük, hogy a tagnyilvántartó azonosító
négykarakteres-e:
if ( strlen( $tagazonosito ) == 4)
print "Köszönöm!";
else
print "Az azonosítónak négykarakteresnek kell lennie
";
Ha a $tagazonosito globális változó értéke négykarakteres, megköszönjük
a felhasználónak, hogy rendelkezésünkre bocsátotta, más esetben hibaüzenetet
jelenítünk meg.
Karakterláncok kezelése 329
17
Szövegrész megkeresése az strstr() függvénnyel
Ezzel a függvénnyel azt állapíthatjuk meg, hogy egy karakterlánc megtalálható-e
beágyazva egy másik karakterláncban. Az strstr() függvény két paramétert
kap bemenetéül: a keresendõ szöveget és a forrásláncot, azaz azt a karakterláncot,
amelyben keresnie kell. Ha a keresett karakterlánc nem található a szövegben,
a visszatérési érték false (hamis) lesz, ellenkezõ esetben a függvény a forrásl
áncból a keresett karakterlánccal kezdõdõ részt adja vissza. A következõ példá-
ban megkülönböztetetten kezeljük azokat a tagazonosítókat, amelyekben
megtalálható az AB karakterlánc:
$tagazonosito = "pAB7";
if ( strstr( $tagazonosito, "AB" ) )
print "Köszönöm. Ne feledje, hogy tagsága hamarosan
lejár!";
else
print "Köszönöm!";
Mivel a $tagazonosito változó tartalmazza az AB karakterláncot, az strstr()
az AB7 karakterláncot adja vissza. Ez true (igaz) eredménynek számít, így
egy különleges üzenetet ír ki. Mi történik akkor, ha a felhasználó a "pab7" karakterl
áncot adja meg? Az strstr() megkülönbözteti a kis- és nagybetûket, így
nem találja meg az AB karakterláncot. Az if utasítás feltétele nem válik igazzá, így
a szokványos üzenet kerül a böngészõhöz. Ha vagy AB-t, vagy ab-t szeretnénk
kerestetni a szövegben, használjuk az stristr() függvényt, melynek mûködése
azonos az strstr()-ével, viszont nem különbözteti meg a kis- és nagybetûket.
Részlánc elhelyezkedésének meghatározása
az strpos() függvénnyel
Az strpos() függvény segítségével kideríthetjük, hogy egy szöveg megtalálható-e
egy másik szöveg részeként, és ha igen, hol. Bemenetét két paraméter képezi,
a forráslánc, amelyben keresünk, és a karakterlánc, amelyet keresünk. Ezek mellett
létezik még egy harmadik, nem kötelezõ paraméter, mégpedig azt az indexet
megadó egész szám, amelytõl kezdve keresni szeretnénk. Ha a keresett karakterlánc
nem található, a függvény a false (hamis) értéket adja vissza, ellenkezõ esetben
azt az egész számot, mely indextõl a keresett szöveg kezdõdik. A következõ programr
észletben az strpos() függvénnyel gyõzõdünk meg arról, hogy egy karakterl
ánc az mz karakterekkel kezdõdik-e:
$tagazonosito = "mz00xyz";
if ( strpos($tagazonosito, "mz") === 0 )
print "Üdv, mz.";
330 17. óra
Vegyük szemügyre azt a trükköt, amellyel a kívánt eredményt kaptuk. Az strpos()
megtalálja az mz karaktersort a lánc elején. Ez azt jelenti, hogy 0 értéket ad vissza,
ami viszont a kifejezés kiértékelése során hamis értéket eredményezne. Hogy ezt
elkerüljük, a PHP 4 új azonosság mûveleti jelét (===) alkalmazzuk, amely akkor
ad vissza true (igaz) értéket, ha bal és jobb oldali operandusa egyenlõ értékû és
azonos típusú is egyben.
Szövegrészlet kinyerése a substr() függvénnyel
A substr() függvény egy kezdõindextõl kezdve meghatározott hosszúságú
karakterláncot ad vissza. Bemenetét két paraméter képezi, az egyik a forráslánc,
a másik a kezdõindex. A függvény az összes karaktert visszaadja a kezdõindextõl
a forráslánc végéig. Harmadik, nem kötelezõ paramétere egy egész szám, amely
a visszaadandó szöveg hosszát jelenti. Ha ezt is megadjuk, a függvény csak
a meghatározott mennyiségû karaktert adja vissza a kezdõindextõl számítva.
$proba = "gazfickó";
print substr($proba,3); // azt írja ki "fickó"
print substr($proba,3,4); // azt írja ki "fick"
Ha kezdõindexként negatív számot adunk meg, a függvény nem a karakterlánc
elejétõl számolja a karaktereket, hanem a végétõl. A következõ kódrészlet meghat
ározott üzenetet ír ki azoknak, akiknek e-mail címe .hu-val végzõdik.
$cim = "felhasznalo@szolgaltato.hu"
if ( substr( $cim, -3 ) == ".hu" )
print "Ne felejtse el magyar vásárlóinknak járó
speciális ajánlatainkat!";
else
print "Üdvözöljük üzletünkben!";
Karakterlánc elemekre bontása az strtok() függvénnyel
Az strtok() függvénnyel karakterláncok szintaktikai elemzését végezhetjük.
A függvény legelsõ meghívásakor két paramétert vár, az elemzendõ karakterláncot
és egy határolójelet, amely alapján a karakterláncot felbontja. A határolójel tetszõ-
leges számú karakterbõl állhat. A függvény elsõ meghívásakor átmenetileg
a memóriába helyezi a teljes forrásláncot, így a további meghívások alkalmával
már csak a határolójelet kell megadnunk. Az strtok() minden meghívásakor
a következõ megtalált elemet adja vissza, a karakterlánc végére érkezést
a false (hamis) érték visszaadásával jelzi. Ezt a függvényt legtöbbször cikluson
belül használjuk. A 17.3. program egy URL-t bont elemeire: elõször leválasztja
a gazdagépet és az elérési útvonalat a karakterláncról, majd a változó–érték párokat
bontja szét. A 17.3. program eredményét a 17.3. ábrán láthatjuk.
Karakterláncok kezelése 331
17
17.3. program Karakterlánc elemekre bontása az strtok() függvénnyel
1: 
2: 
3: 
5: 
6: 
7: 8: $proba = "http://www.deja.com/qs.xp?
9: OP=dnquery.xp&ST=MS&DBS=2&QRY=developer+php";
10: $hatarolo = "?&";
11: $szo = strtok( $proba, $hatarolo );
12: while ( is_string( $szo ) )
13: {
14: if ( $szo )
15: print "$szo
";
16: $szo = strtok( $hatarolo );
17: }
18: ?>
19: 
20: 
Az strtok() függvény önmagában nem sok mindent támogat, így csak különfé-
le trükkökkel bírhatjuk igazán hasznos munkára. Elõször a $hatarolo változó-
ban tároljuk a határolójelet. Meghívjuk az strtok() függvényt, átadjuk neki
az elemzendõ URL-t és a $hatarolo karakterláncot. Az elsõ eredményt a $szo
változóba helyezzük. A while ciklus feltételében azt ellenõrizzük, hogy a $szo
karakterlánc-e. Ha nem az, tudhatjuk, hogy elértük az URL végét és a feladat
befejezõdött.
Azért ellenõrizzük a visszaadott érték típusát, mert ha egy karakterlánc egy sorá-
ban két határolójel van, az strtok() az elsõ határolójel elérésekor üres karakterl
áncot ad vissza. Így, ha a $szo egy üres karakterlánc, az alábbi példában látható
szokványosabb próbálkozás sikertelen lesz, még akkor is, ha a függvény még
nem érte el a forráslánc végét, mivel a while feltétele hamissá válik:
while ( $szo )
{
$szo = strtok( $hatarolo );
}
332 17. óra
Ha meggyõzõdtünk róla, hogy a $szo változó karakterláncot tartalmaz, elkezdhet
ünk dolgozni vele. Ha a $szo nem üres karakterlánc, megjelenítjük a böngészõ-
ben. Aztán újra meg kell hívnunk a strtok() függvényt, hogy a $szo változót
újabb karakterlánccal töltse fel a következõ kiértékeléshez. Vegyük észre, hogy
a második alkalommal nem adtuk át a függvénynek a forrásláncot. Ha ezt mégis
megtennénk, újra a forráslánc elsõ szavát találná meg, így végtelen ciklusba
kerülnénk.
A karakterláncok kezelése
A PHP 4 a karakterlánc paraméterek kisebb-nagyobb átalakításához számos
függvényt biztosít.
Szöveg tisztogatása a trim() típusú függvényekkel
Ha egy felhasználótól vagy fájlból kapunk információt, sohasem lehetünk biztosak
benne, hogy az adat elõtt vagy után nincs egy vagy több fölösleges elválasztó
karakter. A trim() függvény ezeket az elválasztó karaktereket (soremelés, tabul
átorjel, szóköz stb.) hagyja el a karakterlánc elejérõl és végérõl. Bemenete
a megtisztítandó szöveg, kimenete pedig a megtisztított.
$szoveg = "\t\t\teléggé levegõs ez a szöveg ";
$szoveg = trim( $szoveg );
print $szoveg
// azt írja ki, hogy "eléggé levegõs ez a szöveg"
Persze lehet, hogy ez a túlbuzgó függvény nem a legmegfelelõbb számunkra.
Elképzelhetõ, hogy a szöveg elején levõ elválasztó karaktereket meg szeretnénk
tartani és csak a szöveg végérõl akarjuk eltávolítani azokat. Pontosan erre
a feladatra találták ki a chop() függvényt. Vigyázzunk, ha Perl ismeretekkel is
rendelkezünk, mivel ott a chop() függvény egy kicsit más jelentéssel bír. A probl
éma áthidalására a PHP fejlesztõi ugyanezen szolgáltatás eléréséhez megadták
az rtim() függvénynevet is.
$szoveg = "\t\t\teléggé levegõs ez a szöveg ";
$szoveg = chop( $szoveg );
print $szoveg
// azt írja ki, hogy " eléggé levegõs ez a szöveg"
Lehetõségünk van az ltrim() függvény használatára is, amely az elválasztó
karaktereket csak a karakterlánc elejérõl távolítja el. Ahogy az elõzõeknél is,
bemenete az átalakítandó szöveg, kimenete pedig az elválasztó karakterektõl
csupán a bal oldalán mentes karakterlánc:
Karakterláncok kezelése 333
17
$szoveg = "\t\t\teléggé levegõs ez a szöveg ";
$szoveg = ltrim( $szoveg );
print $szoveg
// azt írja ki, hogy "eléggé levegõs ez a szöveg "
Karakterlánc részének lecserélése
a substr_replace() függvénnyel
A substr_replace() hasonlóan mûködik, mint a substr(), a különbség
abban rejlik, hogy itt lehetõség nyílik a kivonatolt karakterlánc-részlet lecserélésére
is. A függvény három paramétert vár: az átalakítandó karakterláncot, a csereszö-
veget és a kezdõindexet. Ezek mellett létezik egy nem kötelezõ, negyedik hosszú-
ság paraméter is. A substr_replace() függvény megtalálja a kezdõindex és
a hosszúság paraméter által meghatározott részláncot, lecseréli azt a csereszövegre,
és a teljes átalakított karakterláncot adja vissza.
A következõ kódrészletben egy felhasználó tagazonosítójának megújításához
le kell cserélnünk annak harmadik és negyedik karakterét:
$tagazonosito = "mz99xyz";
$tagazonosito = substr_replace( $tagazonosito, "00", 2, 2 );
print "Az új tagnyilvántartó azonosító: $tagazonosito
";
// azt írja ki, hogy "Az új tagnyilvántartó azonosító:
mz00xyz"
?>
Az összes részlánc lecserélése
az str_replace() függvénnyel
Az str_replace() függvény a keresett karakterlánc-rész összes elõfordulását
lecseréli egy másik karakterláncra. Bemenetének három paramétere a lecserélend
õ karakterlánc, a csereszöveg és a forrásszöveg. A függvény kimenete az átalakí-
tott karakterlánc. A következõ példában egy karakterláncban az 1999 összes
elõfordulását 2000-re cseréljük:
$karakterlanc = "Ezt az oldal 1999-ben szerzõi jog által
védett";
$karakterlanc .= "Felsõoktatási tájékoztató 1999";
print str_replace("1999","2000",$karakterlanc);
334 17. óra
Kis- és nagybetûk közti váltás
A PHP több függvénnyel is segítségünkre van a kis- és nagybetûk cseréjében.
Amikor felhasználók által beírt adattal dolgozunk, fontos lehet mindent csupa
nagybetûsre vagy csupa kisbetûsre alakítani, hogy aztán könnyebben összehasonl
íthatóak legyenek. Az strtoupper() függvény segítségével egy karakterláncot
csupa nagybetûsre alakíthatunk. A függvény egyetlen bemenete az átalakítandó
szöveg, visszatérési értéke pedig a csupa nagybetûs karakterlánc:
$tagazonosito = "mz00xyz";
$tagazonosito = strtoupper( $tagazonosito );
print "$tagazonosito
"; // azt írja ki, hogy "MZ00XYZ"
Karakterláncunk csupa kisbetûssé való alakításához használjuk az strtolower()
függvényt. Ennek egyetlen bemenete az átalakítandó szöveg és a csupa kisbetûs
karakterláncot adja vissza:
$honlap_url = "WWW.KISKAPU.HU";
$honlap_url = strtolower( $honlap_url );
if ( ! ( strpos ( $honlap_url, “http://” ) === 0 ) )
$honlap_url = "http://$honlap_url";
print $honlap_url; // azt írja ki, hogy
"http://www.kiskapu.hu"
A PHP-nek van egy nagyszerû, „tüneti kezelést” biztosító függvénye, az ucwords().
Ez a függvény egy karakterlánc minden szavának elsõ betûjét teszi nagybetûssé.
A következõ programrészletben a felhasználó által beírt karakterláncban a szavak
elsõ betûjét nagybetûre cseréljük:
$teljes_nev = "vitéz tinódi lantos sebestyén";
$teljes_nev = ucwords( $teljes_nev );
print $teljes_nev; // azt írja ki, hogy "Vitéz Tinódi
Lantos Sebestyén"
A függvény kizárólag a szavak elsõ betûjét cseréli le, így ha a felhasználónak
nehézségei vannak a SHIFT billentyûvel és azt írta be, hogy "ViTÉz tINóDi
laNtos sEBeSTyéN", ez a függvény nem sokban lesz segítségére, hiszen a tü-
neti kezelés eredménye "ViTÉz TINóDi LaNtos SEBeSTyéN" lesz. Ezen
úgy segíthetünk, hogy az ucwords() meghívása elõtt az strtolower() függv
énnyel elõször csupa kisbetûssé alakítjuk a karakterláncot:
$teljes_nev = "ViTÉz tINóDi laNtos sEBeSTyéN";
$teljes_nev = ucwords( strtolower($teljes_nev) );
print $teljes_nev; // azt írja ki, hogy "Vitéz Tinódi
Lantos Sebestyén"
Karakterláncok kezelése 335
17
Fel kell, hogy hívjuk a kedves olvasó figyelmét arra, hogy a magyar szövegekkel
az ékezetes betûk miatt alapbeállításban problémáink akadhatnak. A nemzeti be-
állítások testreszabására használható setlocale() függvényt kell alkalmaznunk,
hogy a kívánt eredményt elérjük.
Karakterláncok tömbbé alakítása
az explode() függvénnyel
A mókásan „robbantó”-nak nevezett függvény bizonyos mértékben hasonló
az strtok() függvényhez. Ez a függvény azonban egy karakterláncot tömbbé bont
fel, amit aztán tárolhatunk, rendezhetünk, vagy azt tehetünk vele, amit csak szeretn
énk. Bemenetét két paraméter alkotja, ez egyik egy határolójel, ami alapján fel szeretn
énk bontani a forrásláncot, a másik maga a forráslánc. A határolójel több karakterb
õl is állhat, ezek együtt fogják alkotni a határolójelet. (Ez eltér az strtok()
függvény mûködésétõl, ahol a megadott karakterlánc minden karaktere egy-egy
önálló határolójel lesz.) A következõ kódrészlet egy dátumot bont fel részeire és az
eredményt egy tömbben tárolja:
$kezdet = "2000.12.01";
$datum_tomb = explode(".", $kezdet);
// $datum_tomb[0] == "2000"
// $datum_tomb[1] == "12"
// $datum_tomb[2] == "00"
Összefoglalás
A PHP külvilággal való kapcsolattartása és adattárolása leginkább karakterláncokon
keresztül valósul meg. Az órán a programjainkban levõ karakterláncok kezelésével
ismerkedtünk meg.
A printf() és az sprintf() függvények segítségével megtanultuk formázni
a karakterláncokat. Ezt a két függvényt olyan karakterláncok létrehozására haszn
áljuk, amelyek egyrészt átalakítják, másrészt el is rendezik az adatokat. Tanultunk
olyan függvényekrõl, amelyek információt árulnak el a karakterláncokról.
Meg tudjuk állapítani egy karakterlánc hosszúságát az strlen(), egy részlánc
jelenlétét az strpos() függvénnyel, vagy kiszakíthatunk részláncokat az
strtok() segítségével.
Végül azokról a függvényekrõl tanultunk, amelyek karakterláncokat alakítanak át.
Most már el tudjuk tüntetni az elválasztó karaktereket a trim(), ltrim() vagy
a chop() függvénnyel, válthatunk a kis- és nagybetûk között az strtoupper(),
az strtolower() és az ucwords() függvényekkel, valamint egy karakterlánc
összes elõfordulását lecseréltethetjük az str_replace() segítségével.
336 17. óra
Ezek után nehéz elhinni, de még mindig nem végeztünk a karakterláncokkal.
A PHP ugyanis támogatja a szabályos kifejezéseket, amelyek a karakterlánckezel
és még hatékonyabb formáját biztosítják. A szabályos kifejezések alkotják
a következõ óra anyagát.
Kérdések és válaszok
Vannak még egyéb hasznos karakterlánc-függvények?
Vannak. A PHP több mint 60 ilyen függvénnyel rendelkezik! Ezekrõl a PHP 4
kézikönyvében olvashatunk, amelynek megfelelõ része
a http://php.net/manual/ref.strings.php címen található.
A printf() mûködését bemutató példában a formázást úgy jelenítettük
meg, hogy a kimenetet 
 elemek közé tettük. Ez a legjobb módja
a formázott szöveg megjelenítésének a böngészõben?
A 
 címkék akkor szükségesek, ha a sima szöveg (plain text) formázást
HTML-es környezetben is meg szeretnénk tartani. Ha viszont a teljes dokumentumot
így szeretnénk megjeleníteni, a legokosabb, ha közöljük a böngészõvel, hogy
sima szövegként formázza meg azt. Ez a header() függvénnyel érhetõ el:
Header("Content-type: text/plain");
Mûhely
A mûhelyben kvízkérdések találhatók, melyek segítenek megszilárdítani az órában
szerzett tudást. A válaszokat az A függelékben helyeztük el.
Kvíz
1. Milyen átalakító paramétert használnánk a printf() függvényben
egy egész szám lebegõpontos számként való megformázására?
2. Hogyan egészítsük ki az 1. kérdésben átalakított számot nullákkal úgy, hogy
a tizedespont elõtti (attól balra esõ) rész 4 karakter hosszúságú legyen?
3. Hogyan kerekítenénk az elõzõ kérdés lebegõpontos számát
két tizedesjegyre?
4. Milyen függvényeket használnánk egy szöveg hosszának kiderítéséhez?
5. Milyen függvényeket használnánk egy részlánc más karakterláncon belüli
kezdetének meghatározására?
Karakterláncok kezelése 337
17
6. Milyen függvényeket használnánk arra, hogy egy szövegbõl kivonjuk annak
egy darabját?
7. Hogyan távolíthatjuk el az elválasztó karaktereket egy karakterlánc elejérõl?
8. Hogyan alakítanánk át egy karakterláncot csupa nagybetûsre?
9. Hogyan bontanánk fel egy határolójelekkel elválasztott karakterláncot
tömbökre?
Feladatok
1. Hozzunk létre egy olyan vélemény-visszajelzõ ûrlapot, amely a felhasználó
nevét és e-mail címét kéri be. Használjuk a kis- és nagybetûket átalakító
függvényeket a nevek elsõ betûjének nagybetûsítésére, majd jelenítsük meg
az eredményt a böngészõben. Ellenõrizzük, hogy a cím tartalmaz-e @-jelet,
ha nem, figyelmeztessük a felhasználót.
2. Hozzunk létre egy lebegõpontos és egész számokból álló tömböt. Léptessünk
végig a tömbön és kerekítsük az összes lebegõpontos számot két tizedesjegyre.
Igazítsuk jobbra a kimenetet egy 20 karakter szélességû mezõben.