A tömbök és a kezelésüket segítõ eszközök nagy mértékben növelik a PHP 4
programok rugalmasságát. Ha jól értünk a tömbökhöz, képesek vagyunk nagy
méretû, összetett adatokat tárolni és kezelni.
Ebben az órában bemutatjuk a tömböket és néhány beépített függvényt, amelyek
segítik a velük való boldogulást. Az órában a következõket tanuljuk meg:
• Mik a tömbök és hogyan hozhatók létre?
• Hogyan érhetjük el a tömbökben tárolt adatokat?
• Hogyan rendezhetjük a tömbökben tárolt adatokat?
Mit nevezünk tömbnek?
Mint már tudjuk, a változó egy „vödör”, amiben egy értéket lehet tárolni. Változók
segítségével olyan programot írhatunk, amely információt tárol, dolgoz fel és ír ki.
Egy változóban azonban sajnos csak egy értéket tárolhatunk. A tömb olyan különleges
szerkezetû változó, amelyben nincs ilyen korlátozás. Egy tömbbe annyi adatot
lehet beletenni, amennyit csak akarunk (amennyi memóriánk van). Minden elemet
egy szám vagy egy karakterlánc segítségével azonosíthatunk. Ha a változó
„vödör”, akkor a tömb „iratszekrény”, tehát olyan tároló, amelyben sok-sok elemet
tárolhatunk.
A tömb változók listája. Több változót tartalmaz, amelyeket számok vagy
karakterláncok segítségével azonosíthatunk, így a különbözõ értékeket
egyetlen névvel tárolhatjuk, rendezhetjük és érhetjük el.
Természetesen ha öt értéket kell tárolnunk, megadhatunk öt változót is. Akkor mi-
ért jó tömböt használni változók helyett? Elõször is azért, mert a tömb rugalmasabb
adatszerkezet. Lehet benne két vagy akár kétszáz érték és ennek elérése érdek
ében nem kell további változókat létrehozni. Másodszor, a tömbök elemeit
könnyedén kezelhetjük egységként is. Ha akarjuk, végighaladhatunk a tömbön
egy ciklussal vagy elérhetjük az elemeit egyenként. Lehetõségünk van a tömböt
rendezni szám szerint, szótári rendezés szerint vagy saját rendezõelv alapján.
A tömb elemeit az index segítségével könnyen elérhetjük. Az index lehet szám,
de akár karakterlánc is.
Alapértelmezés szerint a tömböket számokkal indexeljük, mégpedig úgy, hogy
az elsõ elem indexe 0. Ebbõl az következik, hogy az utolsó tömbelem indexe
mindig eggyel kisebb a tömb méreténél. Tehát az öt elemû tömb utolsó eleme
a 4-es indexû elem. Ezt ajánlatos mindig fejben tartani!
A 7.1. táblázatban a felhasznalok tömböt láthatjuk. Figyeljük meg, hogy példá-
ul a tömb harmadik elemének indexe 2.
7.1. táblázat A felhasznalok tömb elemei
Index Érték Hányadik elem
0 Berci Elsõ
1 Mariska Második
2 Aladár Harmadik
3 Eleonóra Negyedik
ÚJDONSÁG
98 7. óra
A karakterlánccal való indexelés akkor lehet hasznos, ha egyedi nevek (kulcsok)
mellett más értékeket is tárolni kell.
A PHP 4 mind a számokkal, mind a „nevekkel” indexelt tömbök elérésére biztosít
segédeszközöket. Ezek közül néhánnyal ebben a fejezetben is találkozni fogunk,
másokat a tizenhatodik, adatmûveletekkel foglalkozó fejezetben ismerünk
majd meg.
Tömbök létrehozása
A tömbök alapértelmezés szerint értékek számmal indexelt listái. Értéket egy
tömbhöz kétféleképpen is rendelhetünk: Az egyik mód az array() függvény,
a másik a tömbazonosító használata szögletes zárójelekkel ([]). A következõ két
részben mind a kétféle változattal találkozni fogunk.
Tömbök létrehozása az array() függvény segítségével
Az array() függvény akkor hasznos, ha egyszerre több értéket szeretnénk egy
tömbhöz rendelni. Hozzunk létre egy $felhasznalok nevû tömböt és rendelj
ünk hozzá négy elemet!
$felhasznalok = array ("Berci", "Mariska", "Aladár", "Eleonóra");
Most a $felhasznalok tömb harmadik elemét, melynek indexe 2, írassuk ki!
print $felhasznalok[2];
Ez a következõ karakterláncot fogja kiírni: "Aladár". Az indexet a tömb neve
után közvetlenül következõ szögletes zárójelbe kell írni. A tömbelem írásakor és
olvasásakor is ezt a jelölést kell használni.
Ne felejtsük el, hogy a tömbök indexelése nullától indul, így bármely tömbelem
indexe eggyel kisebb a tömbelem tömbbéli helyénél. (Az elsõ elem indexe 0,
a második elem indexe 1.)
Tömb létrehozása vagy elem hozzáadása a tömbhöz
szögletes zárójel segítségével
Tömböket úgy is létrehozhatunk, illetve meglevõ tömbökhöz új elemeket adhatunk,
ha a tömb neve után olyan szögletes zárójelpárt írunk, amelynek belsejében
nincs index.
Tömbök 99
7
100
Hozzuk létre újra a $felhasznalok nevû tömböt:
$felhasznalok[] = "Berci";
$felhasznalok[] = "Mariska";
$felhasznalok[] = "Aladár";
$felhasznalok[] = "Eleonóra";
Figyeljük meg, hogy nem kellett számot írnunk a szögletes zárójelbe. A PHP 4
automatikusan meghatározza az indexértéket, így nem kell nekünk bajlódni azzal,
hogy kiszámítsuk a következõ olyan indexet, amelyben még nincs érték.
Persze írhattunk volna számokat is a szögletes zárójelbe, de ez nem tanácsos.
Nézzük a következõ programrészletet:
$felhasznalok[0] = "Berci";
$felhasznalok[200] = "Mariska";
A tömbnek így mindössze két eleme van, de az utolsó elem indexe 200. A PHP 4
nem fog értéket adni a köztes elemeknek, ami félreértésekre adhat okot az elemek
elérésekor.
Tömbök létrehozása mellett a tömbváltozók szögletes zárójele segítségével
az array() függvénnyel létrehozott tömb végéhez új elemet is adhatunk.
Az alábbi kis programrészletben létrehozunk egy tömböt az array() függvény
segítségével, majd új elemet adunk a tömbhöz szögletes zárójellel.
$felhasznalok = array ("Berci", "Mariska", "Aladár", "Eleonóra");
$felhasznalok[] = "Anna";
Asszociatív tömbök
A számmal indexelt tömbök akkor hasznosak, ha abban a sorrendben szeretnénk
tárolni az elemeket, amilyen sorrendben a tömbbe kerültek. Néha azonban jó lenne,
ha a tömb elemeit meg tudnánk nevezni. Az asszociatív tömb egy karakterláncokkal
indexelt tömb. Képzeljünk el egy telefonkönyvet: melyik a jobb megoldás: a név
mezõt a 4-gyel vagy a “név”-vel indexelni?
A karakterlánccal indexelt tömböket asszociatív tömböknek
(néha hash-nek) hívják.
ÚJDONSÁG
7. óra
Asszociatív tömbök létrehozása a számokkal indexelt tömbökkel megegyezõen
történik, az array() függvény vagy a szögletes zárójelek segítségével.
Asszociatív tömbök létrehozása
az array() függvény segítségével
Ha asszociatív tömböt szeretnénk létrehozni az array() függvény segítségével,
minden elemnek meg kell adni a kulcsát és az értékét. Az alábbi programrészlet
egy $karakter nevû asszociatív tömböt hoz létre négy elemmel.
$karakter = array
(
"nev" => "János",
"tevekenyseg" => "szuperhõs",
"eletkor" => 30,
"kulonleges kepesseg" => "röntgenszem"
);
Most elérhetjük a $karakter elemeit (mezõit):
print $karakter["eletkor"];
Asszociatív tömbök létrehozása és
elérése közvetlen értékadással
Asszociatív tömböt úgy is létrehozhatunk vagy új név–érték párt adhatunk hozzá,
ha egyszerûen a megnevezett elemhez (mezõhöz) új értéket adunk. Az alábbiakban
újra létrehozzuk a $karakter nevû tömböt, úgy, hogy az egyes kulcsokhoz
egyenként rendelünk értékeket.
Tömbök 101
7
A számmal és a karakterlánccal indexelt tömbök közti határvonal
a PHP-ben nem éles. Nem különbözõ típusok, mint a Perlben,
ennek ellenére helyes az a hozzáállás, ha külön-külön kezeljük
õket, mert az egyes típusok más hozzáférési és kezelési módot
igényelnek.
$karakter["nev"] => "János";
$karakter["tevekenyseg"] => "szuperhõs";
$karakter["eletkor"] => 30;
$karakter["kulonleges kepesseg"] => "röntgenszem";
Többdimenziós tömbök
Eddig azt mondtuk, hogy a tömbök elemei értékek. A $karakter tömbünkben
az elemek közül három karakterláncot tartalmaz, egy pedig egy egész számot.
A valóság ennél egy kicsit bonyolultabb. Egy tömbelem valójában lehet érték, objektum
vagy akár egy másik tömb is. A többdimenziós tömb valójában tömbök
tömbje. Képzeljük el, hogy van egy tömbünk, amelynek tömbök az elemei. Ha el
akarjuk érni a második elem harmadik elemét, két indexet kell használnunk:
$tomb[1][2]
A tömböt, amelynek elemei tömbök, többdimenziós tömbnek hívjuk.
A tény, hogy egy tömbelem lehet tömb is, lehetõséget biztosít arra, hogy kifinomultabb
adatszerkezeteket kezeljünk viszonylag egyszerûen. A 7.1. példaprogram
egy tömböt ír le, amelynek elemei asszociatív tömbök.
7.1. program Többdimenziós tömb létrehozása
1:
2:
3:
4:
5:
6: 7: $karakter = array
8: (
9: array (
10: "nev" => "János",
11: "tevekenyseg" => "szuperhõs",
12: "eletkor" => 30,
13: "kulonleges kepesseg" => "röntgenszem"
14: ),
ÚJDONSÁG
102 7. óra
7.1. program (folytatás)
15: array (
16: "nev" => "Szilvia",
17: "tevekenyseg" => "szuperhõs",
18: "eletkor" => 24,
19: "kulonleges kepesseg" => "nagyon erõs"
20: ),
21: array (
22: "nev" => "Mari",
23: "tevekenyseg" => "fõgonosz",
24: "eletkor" => 63,
25: "kulonleges kepesseg" =>
"nanotechnológia"
26: )
27: );
28:
29: print $karakter[0]["tevekenyseg"]; //kiírja, hogy
szuperhõs
30: ?>
31:
32:
Figyeljük meg, hogy array() függvényhívásokat építettünk egy array()
függvényhívásba. Az elsõ szinten adjuk meg a tömböt, melynek minden eleme
asszociatív tömb.
A $karakter[2] tömbelemhez történõ hozzáféréskor a legfelsõ szintû tömb
harmadik elemét, egy asszociatív tömböt kapunk. Az asszociatív tömb bármely
elemét elérhetjük, például a $karakter[2]["nev"] értéke "Mari" lesz,
a $karakter[2]["eletkor"] pedig 63.
Ha a fogalmak tiszták, asszociatív és hagyományos tömbök párosításával
egyszerûen hozhatunk létre összetett adatszerkezeteket.
Tömbök 103
7
Tömbök elérése
Eddig azt láttuk, hogyan kell tömböket létrehozni és elemeket adni azokhoz.
Most végignézünk néhány lehetõséget, amit a PHP 4 a tömbök elérésére biztosít.
Tömb méretének lekérdezése
A tömb bármely elemét elérhetjük indexének használatával:
print $felhasznalo[4];
A tömbök rugalmassága miatt nem mindig egyszerû feladat kideríteni, hány elem
van a tömbben. A PHP a count() függvényt biztosítja erre a feladatra.
A count() a tömbben levõ elemek számával tér vissza. Az alábbi programrészben
egy számokkal indexelt tömböt hozunk létre, majd a count() függvényt
használjuk a tömb utolsó elemének elérésére.
$felhasznalok = array ("Berci", "Marci", "Ödön", "Télapó");
$felhasznalok[count($felhasznalok)-1];
Figyeljük meg, hogy egyet ki kellett vonnunk a count() által visszaadott értékbõl.
Ez azért van így, mert a count() nem az utolsó elem indexét adja vissza, hanem
a tömbelemek számát.
Semmi sem garantálja, hogy ezzel a módszerrel bármilyen (számokkal indexelt)
tömb utolsó elemét megkapjuk. Vegyük például az alábbi programot:
$tomb = array("Ecc, pecc"); // Egyelemû tömb!
$tomb[2] = "kimehetsz";
print "Az utolsó elem: " . $tomb[count($tomb)-1];
A fenti kódot futtatva azt tapasztaljuk, hogy az "Az utolsó elem: " szöveg
után semmi nem íródik ki. Ez azért van, mert a tömbnek nincs 1 indexû eleme.
Az elsõ elem a 0 indexen található, a második a 2 indexen, mivel az értékadáskor
az indexet közvetlenül határoztuk meg.
A tömbök indexelése alapértelmezés szerint nullától indul, de ezt meg lehet
változtatni. Ha azonban világos és következetes programokat szeretnénk írni,
ne éljünk ezzel a lehetõséggel.
Tömb bejárása
Több módja van annak, hogy egy tömb minden elemét végigjárjuk. Mi most a PHP 4
igen hatékony foreach szerkezetét használjuk, de a tizenhatodik órában további
módszereket is megvizsgálunk.
104 7. óra
A számmal indexelt tömbökre a foreach szerkezetet így kell használni:
foreach($tombnev as $atmeneti)
{
}
$tombnev a tömb neve, amit végig szeretnénk járni, az $atmeneti pedig
egy változó, amelybe minden ismétlés során a tömb egy-egy eleme kerül.
Az alábbi példában egy számmal indexelt tömböt hozunk létre és a foreach
vezérlési szerkezet segítségével érjük el annak elemeit:
$felhasznalok = array ("Berci", "Marci", "Ödön");
$felhasznalok[10] = "Télapó";
foreach($felhasznalok as $szemely)
{
print"$szemely
";
}
A program kimenetét a 7.1-es ábrán láthatjuk.
A tömb minden eleme átmenetileg a $szemely változóba került, amit a program
kiír a böngészõbe. A Perlben gyakorlattal rendelkezõk vigyázzanak, a foreach
szerkezet a két nyelvben jelentõsen különbözik! A Perlben ha az átmeneti változó
értékét megváltoztatjuk, a megfelelõ tömbelem is megváltozik.
Tömbök 105
7
A foreach a PHP 4-es változatában került a nyelvbe.
7.1. ábra
Tömb bejárása
Ha ugyanezt az elõzõ példában tesszük, a $felhasznalok tömb értéke nem fog
megváltozni. A tizenhatodik órában látni fogjuk, hogyan módosíthatjuk
a foreach segítségével a tömbök tartalmát.
Figyeljük meg, hogy annak ellenére, hogy a tömb „lyukas”, a program a foreach
szerkezet segítségével bejárt tömb minden elemét kiírta és az utolsó sor elõtt nem
jelentek meg üres sorok, tehát a 3 és 9 indexek közötti tömbelemeket (melyek
nem meghatározottak, vagyis üres karakterláncok) nem írja ki a program.
Asszociatív tömb bejárása
Ha az asszociatív tömb kulcsát és értékét is el szeretnénk érni, egy kicsit másképpen
kell a foreach szerkezet használnunk.
Asszociatív tömböknél a foreach így alkalmazható:
foreach( $tomb as $kulcs => $ertek )
{
// a tömbelem feldolgozása
}
ahol $tomb a tömb neve, amin végig szeretnénk menni, $kulcs a változó,
amelyben az elem kulcsa jelenik meg, a $ertek pedig a kulcshoz tartozó tömbelem
értéke.
A 7.2. példaprogramban létrehozunk egy asszociatív tömböt, majd egyesével
elérjük és kiírjuk a tömb elemeit
106 7. óra
Ahol csak mód van rá, ne használjunk tömbindexeket. A tömbö-
ket sokszor csak egyszerû listaként használjuk, ahol nem számít
az, hogy egy adott elemnek mi az indexe. A PHP a tömbök
elérésére a tömbindexek használatánál hatékonyabb és áttekinthet
õbb függvényeket biztosít, programunk ezáltal rugalmasabb,
könnyebben módosítható és jól olvasható lesz.
7.2. program Asszociatív tömb bejárása a foreach segítségével
1:
2:
3:
4:
5:
6: 7: $karakter = array (
8: "nev" => "János",
9: "tevekenyseg" => "szuperhõs",
10: "eletkor" => 30,
11: "kulonleges kepesseg" => "röntgenszem"
12: );
13:
14: foreach ( $karakter as $kulcs => $ertek )
15: {
16: print "$kulcs = $ertek
";
17: }
18: ?>
19:
20:
A 7.2. példaprogram kimenetét a 7.2. ábrán láthatjuk.
Tömbök 107
7
7.2. ábra
Asszociatív tömb
bejárása
Többdimenziós tömb bejárása
Most már ismerünk olyan módszereket, amelyek segítségével a 7.1. példaprogramban
létrehozott többdimenziós tömböt bejárhatjuk. A 7.3. példaprogramban
létrehozunk egy többdimenziós tömböt és a foreach segítségével végigjárjuk
az elemeit.
7.3. program Többdimenziós tömb bejárása
1:
2:
3:
4:
5:
6: 7: $karakterek = array
8: (
9: array (
10: "nev" => "János",
11: "tevekenyseg" => "szuperhõs",
12: "eletkor" => 30,
13: "kulonleges kepesseg" => "röntgenszem"
14: ),
15: array (
16: "nev" => "Szilvia",
17: "tevekenyseg" => "szuperhõs",
18: "eletkor" => 24,
19: "kulonleges kepesseg" => "nagyon erõs"
20: ),
21: array (
22: "nev" => "Mari",
23: "tevekenyseg" => "fõgonosz",
24: "eletkor" => 63,
25: "kulonleges kepesseg" =>
"nanotechnológia"
26: )
27: );
108 7. óra
7.3. program (folytatás)
28: foreach ( $karakterek as $karakter )
29: {
30: foreach ( $karakter as $kulcs => $ertek )
31: {
32: print "$kulcs: $ertek
";
33: }
34: print "
";
35: }
36: ?>
37:
38:
A 7.3. példaprogram kimenetét a 7.3. ábrán láthatjuk. Két foreach ciklust haszn
álunk. A külsõ ciklusban a számmal indexelt $karakterek tömb elemeit
vesszük végig, az egyes elemek pedig a $karakter nevû változóba kerülnek.
A $karakter maga is egy tömb, ezért ennek értékeit is egy foreach ciklussal
járjuk végig. Mivel a $karakter egy asszociatív tömb, a foreach szerkezetet
az ennek megfelelõ formában használjuk, a kulcs-érték párok pedig a $kulcs és
az $ertek változókba kerülnek.
Annak érdekében, hogy ez a módszer jól mûködjön, biztosnak kell lennünk abban,
hogy a $karakter változó valóban mindig tömböt tartalmaz. A kódot megbízhat
óbbá tehetnénk, ha meghívnánk a $karakter változóra az is_array() függv
ényt. Az is_array() függvény számára egy paramétert kell megadnunk.
A visszatérési érték true lesz, ha a változó típusa tömb, minden más esetben
false értéket ad.
Tömbök 109
7
Bonyolultabb programok esetében gyakran elõfordul, hogy
kíváncsiak vagyunk egy tömb vagy valamilyen más összetett
változó tartalmára. Ilyenkor általában nem kell saját tömblistázó
kódot használnunk, hiszen a PHP 4 biztosítja számunkra
a print_r() függvényt, amely a paramétereként megadott változó
tartalmát írja ki.
Mûveletek tömbökkel
Most már fel tudunk tölteni tömböket elemekkel, elérhetjük azokat, de a PHP rengeteg
függvénnyel segíti a tömbök feldolgozását is. A Perlben jártas olvasó bizony
ára ismerõsnek fogja találni ezen függvények nagy részét.
Két tömb egyesítése az array_merge() függvény
segítségével
Az array_merge() függvény legalább két paramétert vár: az egyesítendõ tömbö-
ket. A visszatérési érték az egyesített tömb lesz. Az alábbi példában létrehozunk két
tömböt, egyesítjük azokat, majd végigjárjuk a keletkezõ harmadik tömböt:
$elso = array( "a", "b", "c" );
$masodik = array( 1, 2, 3 );
$harmadik = array_merge( $elso, $masodik );
foreach( $harmadik as $ertek )
{
print "$ertek
";
}
A $harmadik tömb az $elso és a $masodik tömbök elemeinek másolatát tartalmazza.
A foreach ciklus ennek a tömbnek az elemeit ("a", "b", "c", 1, 2, 3)
írja ki a böngészõbe. Az egyes elemeket a
(sortörés) választja el egymástól.
Egyszerre több elem hozzáadása egy tömbhöz
az array_push() függvény segítségével
Az array_push() függvény egy tömböt és tetszõleges számú további paramétert
fogad. A megadott értékek a tömbbe kerülnek. Figyeljük meg, hogy
az array_merge() függvénnyel ellentétben az array_push() megváltoztatja
elsõ paraméterének értékét. E függvény visszatérési értéke a tömbben lévõ elemek
száma (miután az elemeket hozzáadta). Hozzunk létre egy tömböt, majd adjunk
hozzá néhány elemet:
110 7. óra
Az array_merge() függvény a PHP 4-es változatában került
a nyelvbe.
$elso = array( "a", "b", "c" );
$elemszam = array_push( $elso, 1, 2, 3 );
print "Összesen $elemszam elem van az \$elso tömbben
";
foreach( $elso as $ertek )
{
print "$ertek
";
}
Mivel az array_push() függvény visszaadja a módosított tömb elemeinek
számát, az értéket (ami ebben az esetben 6) egy változóban tárolhatjuk és kiírathatjuk
a böngészõbe. Az $elso tömb ekkor az eredeti három betût tartalmazza,
melyekkel az elsõ sorban feltöltöttük, illetve a három számot, amit
az array_push() függvény segítségével adtunk hozzá. Az így létrehozott
tömb elemeit a foreach ciklus segítségével kiíratjuk a böngészõbe.
Figyeljük meg, hogy a "$elso" karakterlánc elé egy fordított perjelet kellett
tennünk. Ha a PHP egy macskakörmös (kettõs idézõjeles) karakterláncban egy
dollárjelet követõ betû- és/vagy számsorozatot talál, változóként próbálja értelmezni
azt és megkísérli az értékét beírni. A fenti példában mi a '$elso' karaktersorozatot
szerettük volna megjeleníteni, ezért kellett a dollárjel elé a fordított
perjel karakter. Így a PHP már nem próbálja meg változóként értelmezni, hanem
kiírja a karaktereket. Ezt a módszert a szakirodalomban gyakran escape-ként
emlegetik.
Tömbök 111
7
A Perlben gyakorlattal rendelkezõk figyeljenek arra, hogy ha
a PHP-ben az array_push() második paramétereként tömböt adnak
meg, a tömb egy tömb típusú elemmel bõvül, ezáltal többdimenzi
ós tömb keletkezik. Ha két tömb elemeit szeretnénk
egyesíteni, használjuk az array_merge() függvényt.
Ha egy karakterláncban nem szeretnénk, hogy a változók behelyettes
ítõdjenek, a karakterlánc jelölésére egyszeres idézõjeleket
használjunk; ekkor a ‘ és a \ karakterek helyett \’-t és \\-t kell írnunk.
Az elsõ elem eltávolítása
az array_shift() függvény segítségével
Az array_shift() eltávolítja a paraméterként átadott tömb elsõ elemét és
az elem értékével tér vissza. A következõ példában az array_shift() függvény
segítségével eltávolítjuk a tömb elsõ elemét. Ezt a mûveletet egy while ciklusba
tesszük és a mûveletet addig ismételjük, amíg el nem fogy a tömb. Annak ellenõrz
ésére, hogy van-e még elem a tömbben, a count() függvényt használjuk.
$egy_tomb = array( "a", "b", "c" );
while ( count( $egy_tomb ) )
{
$ertek = array_shift( $egy_tomb );
print "$ertek
";
print '$egy_tomb-ben most ' . count( $egy_tomb )
. 'elem van
';
}
?>
A program kimenetét a 7.4. ábrán láthatjuk.
Az array_shift() akkor lehet hasznos, amikor egy sor elemein kell valamilyen
tevékenységet végezni, amíg a sor ki nem ürül.
112 7. óra
7.4. ábra
A tömb egyes elemeinek
törlése és kiíratá-
sa az array_shift()
függvény segítségével
Az array_shift() függvény a PHP 4-es változatában került
a nyelvbe.
Tömb részének kinyerése
az array_slice() függvény segítségével
Az array_slice() függvény egy tömb egy darabját adja vissza. A függvény
egy tömböt, egy kezdõpozíciót (a szelet elsõ elemének tömbbeli indexét) és
egy (elhagyható) hossz paramétert vár. Ha ez utóbbit elhagyjuk, a függvény felté-
telezi, hogy a kezdõpozíciótól a tömb végéig tartó szeletet szeretnénk megkapni.
Az array_slice() nem változtatja meg a paraméterként átadott tömböt,
hanem újat ad vissza, amelyben a hívó által kért elemek vannak.
Az alábbi példában létrehozunk egy tömböt, majd egy új, három elemû tömböt áll
ítunk elõ belõle:
$elso = array( "a", "b", "c", "d", "e", "f" );
$masodik = array_slice( $elso, 2, 3 );
foreach( $masodik as $ertek )
{
print "$ertek
";
}
A fenti példa a "c", "d" és "e" elemeket írja ki, a
kódelemmel elválasztva.
Mivel kezdõpozícióként a kettõt adtuk meg, így az elsõ elem, ami a $masodik
tömbbe kerül, az $elso[2].
Ha kezdõpozícióként negatív számot adunk meg, a tömbszelet elsõ eleme hátulról
a megadott számú elemtõl kezdõdik. Ez azt jelenti, hogy ha a második paraméter
értéke -1, a tömbszelet az utolsó elemtõl fog kezdõdni.
Ha hossz paraméterként nullánál kisebb számot adunk meg, a visszakapott tömbszelet
a tömb hátulról a megadott számú eleméig tart.
Tömbök rendezése
Talán a rendezés a legnagyszerûbb mûvelet, amit egy tömbön el lehet végezni.
A PHP 4 függvényeinek köszönhetõen egykettõre rendet teremthetünk a káoszban.
A következõ rész néhány olyan függvényt mutat be, amelyek számmal és karakterl
ánccal indexelt tömböket rendeznek.
Tömbök 113
7
Az array_slice() függvény a PHP 4-es változatában jelent meg.
Számmal indexelt tömb rendezése
a sort() függvény segítségével
A sort() függvény egy tömb típusú paramétert vár és a tömb rendezését végzi el.
Ha a tömbben van karakterlánc, a rendezés (alapbeállításban angol!) ábécésorrend
szerinti lesz, ha a tömbben minden elem szám, szám szerint történik. A függvénynek
nincs visszatérési értéke, a paraméterként kapott tömböt alakítja át.
Ebbõl a szempontból különbözik a Perl hasonló függvényétõl. Az alábbi programr
észlet egy karakterekbõl álló tömböt hoz létre, rendezi, majd a rendezett tömb
elemeit egyenként kiírja:
$tomb = array( "x", "a", "f", "c" );
sort( $tomb );
foreach ($tomb as $elem)
{
print "$elem
";
}
Nézzük egy kis példát egy tömb kétféle rendezési módjára!
$tomb = array( 10, 2, 9 );
sort( $tomb );
print '___Rendezés szám szerint___'
;
foreach ($tomb as $elem)
{
print "$elem
";
}
$tomb[]="a";
sort( $tomb );
print '___Rendezés ábécésorrend szerint___
';
foreach ($tomb as $elem)
{
print "$elem
";
}
A fenti példa kimenete:
___Rendezés szám szerint___
2
9
10
114 7. óra
___Rendezés ábécésorrend szerint___
10
2
9
a
Ha csökkenõ sorrendben szeretnénk rendezni egy tömb elemeit, használjuk
a sort() függvényhez hasonlóan mûködõ rsort() függvényt.
Asszociatív tömb rendezése érték szerint
az asort() függvény segítségével
Az asort() függvény egy asszociatív tömb típusú paramétert vár és a tömböt
a sort() függvényhez hasonlóan rendezi. Az egyetlen különbség,
hogy az asort() használata után megmaradnak a karakterlánc-kulcsok:
$a_tomb = array( "elso"=>5, "masodik"=>2, "harmadik"=>1 );
asort( $a_tomb );
foreach( $a_tomb as $kulcs => $ertek )
{
print "$kulcs = $ertek
";
}
Ennek a programocskának a kimenetét a 7.5. ábrán láthatjuk.
Tömbök 115
7
A sort() függvényt ne használjuk asszociatív (karakterlánccal
indexelt) tömbökre! Ha mégis megtesszük, azt fogjuk tapasztalni,
hogy a tömb elemei ugyan rendezettek lesznek, de az
elemek kulcsai elvesznek, az egyes elemek így nullától kezdõdõ
számokkal érhetõk el, ugyanis a tömb számmal indexelt tömbbé
alakul át.
Ha csökkenõ sorrendben szeretnénk rendezni egy asszociatív tömb elemeit,
használjuk a arsort() függvényt.
Asszociatív tömb rendezése kulcs szerint
a ksort() függvény segítségével
A ksort() a paraméterben megadott asszociatív tömböt rendezi kulcs szerint.
A többi tömbrendezõ függvényhez hasonlóan ez a függvény sem ad vissza semmif
éle visszatérési értéket, hanem a tömböt alakítja át:
$tomb = array( "x" => 5, "a" => 2, "f" => 1 );
ksort( $tomb );
foreach( $tomb as $kulcs => $ertek )
{
print "$kulcs = $ertek
";
}
A program kimenetét a 7.6. ábrán láthatjuk.
116 7. óra
7.6. ábra
Asszociatív tömb
rendezése kulcs
szerint a ksort() függv
ény segítségével
7.5. ábra
Asszociatív tömb
érték szerinti rendez
ése az asort() függv
ény segítségével
Összefoglalás
Ebben az órában a tömbökrõl és a hozzájuk kapcsolódó eszközökrõl tanultunk,
melyeket a PHP 4 a rajtuk végzett mûveletekhez nyújt. Most már tudunk normál
(számmal indexelt) és asszociatív (karakterlánccal indexelt) tömböket is létrehozni,
illetve tömböket bejárni a foreach ciklus segítségével.
Többdimenziós tömböket is létre tudunk hozni, a bennük levõ információt pedig
ki tudjuk nyerni egymásba ágyazott foreach ciklusokkal. A tömbökhöz egyszerre
több elemet is adhatunk, illetve onnan kivehetünk. Végül megtanultuk, hogy
a PHP 4-es változata milyen lehetõségeket nyújt a tömbök rendezésére.
Kérdések és válaszok
Ha a foreach ciklus csak a PHP 4-esben került a nyelvbe, akkor a PHP 3-as
változatát használó programozók hogyan jártak végig egy tömböt?
A PHP 3-asban az each() függvényt használták egy while() ciklusban.
Errõl bõvebben a tizenhatodik órában olvashatunk.
Van olyan tömböt kezelõ függvény, amellyel nem foglalkoztunk ebben
az órában?
A PHP 4-es változatában nagyon sok tömbkezelõ függvény van. Errõl bõvebben a tizenhatodik
órában fogunk tanulni. A kézikönyv errõl szóló része megtalálható az
Interneten, a http://www.php.net/manual/en/ref.array.php címen. (A
kézikönyv magyar változata a http://hu.php.net/manual/hu/ oldalon találhat
ó.)
Ha a tömb elemeinek számát ismerem, normál tömb bejárására a for
ciklust használjam? (Ekkor számláló segítségével címzem meg a tömb
elemeit.)
Nagyon óvatosan kell bánni ezzel a megközelítéssel. Nem lehetünk biztosak
abban, hogy az általunk használt tömb indexei 0-tól indulnak és egyesével nõnek.
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. Melyik függvénnyel hozhatunk létre tömböket?
2. Az alább létrehozott tömb utolsó elemének mi az indexe?
$torpek = array( "Tudor", "Vidor", "Kuka" );
Tömbök 117
7
3. Függvények használata nélkül hogyan tudnánk "Hapci"-t az imént létrehozott
$torpek nevû tömbhöz adni?
4. Melyik függvény segítségével tudnánk "Morgó"-t a $torpek nevû tömbbe
felvenni?
5. Hogyan lehet egy tömb elemszámát megtudni?
6. A PHP 4-es változatában mi a legegyszerûbb módja egy tömb bejárásának?
7. Milyen függvény segítségével lehet két tömböt egyesíteni?
8. Hogyan rendeznénk egy asszociatív tömböt kulcsai szerint?
Feladatok
1. Hozzunk létre egy többdimenziós tömböt, amely filmeket tartalmaz, zsáner
szerint rendezve! Pontosabban hozzunk létre egy asszociatív tömböt, amelynek
kulcsai filmtípusok ("Scifi", "Akció", "Romantikus"…)! A tömb elemei
legyenek tömbök, amelyek filmcímeket tartalmaznak ("2001", "Alien",
"Terminator",...)!
2. Járjuk végig az elõzõ feladatban létrehozott tömböt és írjuk ki az összes
filmtípust és a hozzá tartozó filmcímeket!