Hozzáadás a php tömbhöz. Hogyan lehet másik tömböt hozzáadni egy tömbhöz php-ban? Indexelt és asszociatív tömbök
Számos függvény és operátor létezik a tömbök php-ben való konvertálására: Függvénygyűjtemény a tömbökkel való munkavégzéshez
Számos módja van tömb hozzáadásának egy tömbhöz, amikor php segítségés mindegyik hasznos lehet az egyes esetekben.
"Üzemeltető +"
Ez egy egyszerű, de trükkös módszer:
$c = $a + $b
Ez csak azokat a kulcsokat adja hozzá, amelyek még nem szerepelnek az $a tömbben. Az elemek a tömb végére kerülnek.
Ez azt jelenti, hogy ha a $b tömbből származó kulcs nincs az $a tömbben, akkor egy ezzel a kulccsal rendelkező elem hozzáadódik a kapott tömbhöz.
Ha az $a tömbnek már van azonos kulcsú eleme, akkor annak értéke változatlan marad.
Vagyis a kifejezések helyének megváltoztatásával az összeg változik: $a + $b != $b + $a - ezt érdemes megjegyezni.
És most egy részletesebb példa ennek illusztrálására:
$arr1 = ["a" => 1, "b" => 2]; $arr2 = ["b" => 3, "c" => 4]; var_export($arr1 + $arr2); //tömb (// "a" => 1, // "b" => 2, // "c" => 4, //) var_export($arr2 + $arr1); //tömb (// "b" => 3, // "c" => 4, // "a" => 1, //)
array_merge() függvény
Ezt a funkciót a következőképpen használhatja:
$eredmény = array_merge($arr1, $arr2)
Alaphelyzetbe állítja a numerikus indexeket és lecseréli a karakterláncokat. Kiválóan alkalmas két vagy több numerikus indexű tömb egyesítésére:
Ha a bemeneti tömbök ugyanazokkal a karakterlánc-kulcsokkal rendelkeznek, akkor minden következő érték felváltja az előzőt. Ha azonban a tömbök ugyanazokkal a számkulcsokkal rendelkeznek, akkor az utoljára említett érték nem helyettesíti az eredeti értéket, hanem a tömb végére kerül.
array_merge_recursive függvény
Ugyanazt teszi, mint az array_merge, kivéve, hogy rekurzívan átmegy a tömb minden ágán, és ugyanezt teszi a gyerekekkel.
array_replace() függvény
Egy tömb elemeit lecseréli más átadott tömbök elemeire.
array_replace_recursive() függvény
Ugyanaz, mint az array_replace, csak az összes tömbágat dolgozza fel.
Elemek hozzáadása egy tömbhöz
Ha a tömb létezik, további elemeket lehet hozzáadni hozzá. Ez közvetlenül a hozzárendelési operátorral (egyenlőségjel) történik, ugyanúgy, mint egy karakterlánchoz vagy számhoz való érték hozzárendelése. Ebben az esetben nem állíthatja be a hozzáadott elem kulcsát, de minden esetben a tömb elérésekor szükséges szögletes zárójelek. Két új elem hozzáadásával a $List listához írjuk:
$List = "körte";
$List = "paradicsom";
Ha a kulcs nincs beállítva, minden elem hozzáadódik a meglévő tömbhöz, és a következő sorszámmal indexelődik. Ha új elemeket adunk a tömbhöz az előző szakaszból, amelynek elemeinek indexe 1, 2 és 3 volt, akkor a körték indexe 4, a paradicsom (paradicsom) pedig 5. Ha kifejezetten beállít egy indexet, akkor az érték ha már létezik, akkor az adott helyen meglévő érték elvész, és helyébe egy új kerül:
$List = "körte";
$List = "paradicsom";
Most a 4-es indexen lévő elem értéke "paradicsom", és a "narancs" elem már nincs meg. Azt javaslom, hogy ne adjon meg kulcsot, amikor elemeket ad hozzá egy tömbhöz, kivéve, ha kifejezetten felülírja a meglévő adatokat. Ha azonban karakterláncokat használnak indexként, a kulcsokat meg kell adni, hogy ne veszítsenek el értékeket.
A soups.php szkript átírásával megpróbálunk új elemeket hozzáadni a tömbhöz. Először a tömb eredeti elemeit, majd az eredetieket a hozzáadott elemekkel együtt kinyomtatva könnyen láthatjuk a bekövetkezett változásokat. Ahogyan az strlen() függvénnyel megkeresheti egy karakterlánc hosszát (a benne lévő karakterek számát), a count() függvénnyel könnyen megtalálhatja a tömb elemeinek számát is:
$HowMany = count($Array);
- Nyissa meg a soups.php fájlt szöveg szerkesztő.
- Miután inicializálta a tömböt az array() függvénnyel, adja hozzá a következő bejegyzést: $HowMany = count($Levesek);
- Adjon hozzá három további elemet a tömbhöz. $Soups["Thursday"] = "Csirke tészta";
- Számolja újra a tömb elemeit, és nyomtassa ki az értéket. $HowManyNow = count($Levesek);
- Mentse el a szkriptet (7-2. lista), töltse fel a szerverre, és tesztelje a böngészőben (ábra).
print("A tömb $HowMany elemeket tartalmaz.
\n");
A count() függvény határozza meg, hogy hány elem van a $Soups tömbben. Ha ezt az értéket egy változóhoz rendeljük, akkor az kinyomtatható.
$Soups["Friday"] = "Paradicsom";
$Soups["Saturday"] = "Brokkolikrém";
print ("A tömb most $HowManyNow elemeket tartalmaz.
\n");
Lista 7.2 Közvetlenül hozzáadhat egy elemet egy tömbhöz, ha minden elemhez értéket rendel a megfelelő operátor használatával. A count() függvény segítségével megtudhatja, hány elem van egy tömbben.
1
2
3
4
5 6 $levesek = array(
7 "Monday"=>"Clam Chowder",
8 "Kedd"=>"White Chicken Chili",
9 "Wednesday"=>"Vegetáriánus");
11 print ("A tömb tartalmazza a $HowMany
elemeket.
\n");
12 $Soups["Thursday"] = "Csirke tészta";
13 $Soups["Friday"] = "Paradicsom";
14 $Soups["Saturday"] = "Tejszín
Brokkoli";
15 $HowManyNow = count($Levesek);
16 print("A tömb most tartalmazza
$HowManyNow elem.
\n");
17 ?>
18
19
A PHP 4.0-ban megjelent új funkció, amely lehetővé teszi az egyik tömb hozzáadását a másikhoz. Ezt a műveletet tömbök egyesítésének vagy összefűzésének is nevezhetjük. Az array_merge() függvényt így hívjuk:
$NewArray = array_merge($OneArray, $TwoArray);
Ezzel a funkcióval átírhatja a soups.php oldalt, ha olyan szervert futtat, amelyen PHP 4.0 van telepítve.
Két tömb uniója
- Nyissa meg a soups.php fájlt egy szövegszerkesztőben, ha még nincs megnyitva.
- A $Soups tömb inicializálása után számolja meg az elemeit, és nyomtassa ki az eredményt. $HowMany = count($Levesek);
- Két tömböt egyesítsünk egybe. $TheSoups = array_merge($Levesek, $Levesek2);
- Számolja meg az új tömb elemeit, és nyomtassa ki az eredményt. $HowMany3 = count($TheSoups);
- Zárja be a PHP és HTML dokumentumot. ?>
- Mentse el a fájlt (7.3. lista), töltse fel a szerverre, és tesztelje a böngészőben (ábra).
print ("A $Soups tömb $HowMany elemeket tartalmaz.
\n");
- Hozzon létre egy második tömböt, számolja meg az elemeit, és nyomtassa ki az eredményt.
"Thursday">"Csirke tészta",
"Friday">"Paradicsom",
"Saturday"=>"Brokkolikrém");
$Hányan2 = count($Levesek2);
print ("A $Soups2 tömb $HowMany2 elemeket tartalmaz.
\n");
Ügyeljen arra, hogy a tömbök ebben a sorrendben legyenek ($Levesek, majd $Levesek2), vagyis a csütörtök és péntek elemeit hozzá kell adni a hétfő szerda elemeihez, és nem fordítva.
print ("A $TheSoups tömb tartalmazza
-$HowMany3 elem.
\n");
7-3. lista Az Array_merge() függvény új. Ez egyike a PHP 4.0 számos további szolgáltatásának, amelyet tömbökkel való együttműködésre terveztek. A tömbök használatával sok időt takaríthat meg.
1
2
3
4
5 6 $ levesek = tömb!
7 "Monday"=>"Clam Chowder",
"Tuesday">"White Chicken Chili",
8 "Szerda"=>"Vegetáriánus"
9);
10 $HowMany = count($Levesek);
11 print ("A $Soups tömb $HowMany elemeket tartalmaz.
\n");
12 $Levesek2 = array(
13 "Csütörtök"=>"Csirke tészta",
14 "Friday">"Paradicsom",
15 "Szombat"=>"Brokkolikrém"
16); .
17 $HowMany2 = count($Levesek2);
18 print ("A $Soups2 tömb $HowMany2 elemeket tartalmaz.
\n");
19 $TbeSoupe = array_merge($Levesek, $Levesek2);
20 $HowMany3 = count($The Soups) ;
21 print ("A $TheSoups tömb .$HowMany3 elemet tartalmaz.
\n");
22 ?> "
23
24
Legyen óvatos, amikor közvetlenül ad hozzá elemeket egy tömbhöz. Helyesen így lesz: $Ar ray = "Add This"; iyi $argau = "Hozzáadás";, de a helyes út: $argau = "Hozzáadás";. Ha elfelejtette beírni a zárójelet, akkor a hozzáadott érték tönkreteszi a meglévő tömböt, és egyszerű karakterláncsá vagy számmá alakítja.
A PHP 4.0 számos új funkcióval rendelkezik a tömbökkel való munkavégzéshez. Nem mindegyiket tárgyalja a könyv. A témával kapcsolatos teljes körű tájékoztatást azonban a PHP nyelvi útmutatója tartalmazza, amely a PHP webhelyén található. Ügyeljen arra, hogy ne használja az új, csak a PHP 4.0-s szolgáltatásait, ha a szerveren PHP 3.x fut.
array_pad
Több elemet ad hozzá egy tömbhöz.
Szintaxis:
Array array_pad(tömb bemenet, int pad_size, vegyes pad_érték)
Az array_pad() függvény visszaadja annak a bemeneti tömbnek a másolatát, amelyhez a pad_values elemeket hozzáadtuk, így az eredményül kapott tömbben lévő elemek száma megegyezik a pad_size értékkel.
Ha pad_size>0, akkor az elemek a tömb végére kerülnek, és ha<0 - то в начало.
Ha a pad_size értéke kisebb, mint az eredeti bemeneti tömb elemei, akkor nem történik kitöltés, és a függvény az eredeti bemeneti tömböt adja vissza.
Példa az array_pad() függvény használatára:
$arr = array(12, 10, 4);
$eredmény = array_pad($arr, 5, 0);
// $eredmény = array(12, 10, 4, 0, 0);
$eredmény = array_pad($arr, -7, -1);
// $eredmény = array(-1, -1, -1, -1, 12, 10, 4)
$eredmény = array_pad($arr, 2, "noop");
// nem ad hozzá
array_map
Egyéni függvény alkalmazása a megadott tömbök összes elemére.
Szintaxis:
Array array_map(vegyes visszahívás, tömb arr1 [, tömb ...])
Az array_map() függvény egy tömböt ad vissza, amely tartalmazza az összes megadott tömb elemeit, miután az egyéni visszahívási függvény feldolgozta.
Az egyéni függvénynek átadott paraméterek számának meg kell egyeznie az array_map() függvénynek átadott tömbök számával.
array_map() példa: Egyetlen tömb feldolgozása
vissza $n*$n*$n;
}
$a = array(1, 2, 3, 4, 5);
$b = array_map("kocka", $a);
print_r($b);
?>
Sor(
=> 1
=> 8
=> 27
=> 64
=> 125
)
array_map() példa: Több tömb feldolgozása
return "A $n szám spanyolul $m";
}
függvény map_spanyol($n, $m) (
return array($n => $m);
}
$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");
$c = array_map("show_spanish", $a, $b);
print_r($c);
$d = array_map("térkép_spanyol", $a , $b);
print_r($d);
?>
A fenti példa a következőket adja ki:
// $cArray( kinyomtatása
=> Az 1-es szám spanyolul uno
=> A 2-es szám spanyolul dos
=> A 3-as szám spanyolul tres
=> A spanyol 4-es szám cuatro
=> Az 5-ös spanyol nyelven cinco
)
// $dArray( kinyomtatása
=> tömb
=> uno
)
=> tömb
=> dos
)
=> tömb
=> tres
)
=> tömb
=> cuatro
)
=> tömb
=> cinco
)
Általában az array_map() függvényt olyan tömbökre alkalmazzák, amelyek mérete megegyezik. Ha a tömbök különböző hosszúságúak, akkor a kisebbek üres értékű elemekkel vannak kitöltve.
Megjegyzendő, hogy ha a feldolgozó függvény neve helyett null értéket adunk meg, akkor egy tömb tömb jön létre.
Példa az array_map() függvény használatára: Tömbök tömbjének létrehozása
$b = array("egy", "kettő", "három", "négy", "öt");
$c = array("uno", "dos", "tres", "cuatro", "cinco");
$d = array_map(null, $a, $b, $c);
print_r($d);
?>
A fenti példa a következőket adja ki:
Sor(
=> tömb
=> 1
=> egy
=> uno
)
=> tömb
=> 2
=> kettő
=> dos
)
=> tömb
=> 3
=> három
=> tres
)
=> tömb
=> 4
=> négy
=> cuatro
)
=> tömb
=> 5
=> öt
=> cinco
)
Funkciók által támogatott PHP 4 >= 4.0.6, PHP 5
array_pop
Lekéri és eltávolítja a tömb utolsó elemeit.
Szintaxis:
kevert array_pop(tömb arr);
Az array_pop() függvény előugrik az utolsó elemet az arr tömbből, és visszaadja azt, majd eltávolítja. Ezzel a funkcióval veremszerű szerkezeteket építhetünk. Ha az arr tömb üres volt, vagy nem tömb, a függvény egy üres NULL karakterláncot ad vissza.
Az array_pop() függvény használata után a tömbkurzor az elejére áll.
Példa az array_pop() függvény használatára:
$gyümölcs = array_pop($verem);
print_r($verem);
print_r($gyümölcs);
?>
A példa a következőt fogja kiadni:
Sor(
=> narancs
=> banán
=> alma
)
PHP 4, PHP 5 által támogatott funkció
array_push
Egy vagy több elemet ad egy tömb végéhez.
Szintaxis:
int array_push(tömb tömb, vegyes var1 [, vegyes var2, ..])
Az array_push() függvény hozzáadja a var1, var2 stb. elemeket az arr tömbhöz. Numerikus indexeket rendel hozzájuk, akárcsak a standard .
Ha csak egy elemet kell hozzáadnia, valószínűleg egyszerűbb ezt az operátort használni:
Array_push($Arr,1000); // a függvény meghívása $Arr=100; // ugyanaz, de rövidebb
Példa az array_push() függvény használatára:
array_push($verem, "alma", "málna");
print_r($verem);
?>
A példa a következőt fogja kiadni:
Sor(
=> narancs
=> banán
=> alma
=> málna
)
Vegye figyelembe, hogy az array_push() függvény egy tömböt veremként kezel, és mindig a végéhez ad hozzá elemeket.
PHP 4, PHP 5 által támogatott funkció
array_shift
Lekéri és eltávolítja a tömb első elemét.
Szintaxis:
kevert array_shift(tömb tömb)
Az array_shift() függvény kivonja az arr tömb első elemét, és visszaadja azt. Nagyon hasonlít az array_pop(),
de csak a kezdeti elemet kapja, nem a végső elemet, és az egész tömb meglehetősen erős "rázását" produkálja: végül is az első elem kinyerésekor be kell állítani az összes többi elem összes numerikus indexét, mert az összes következő tömbelem egy pozícióval előre van tolva. A karakterlánc tömb kulcsai nem változnak.
Ha az arr üres, vagy nem tömb, a függvény NULL-t ad vissza.
A funkció használata után a tömbmutató az elejére ugrik.
Példa az array_shift() függvény használatára:
$gyümölcs = array_shift($verem);
print_r($verem);
?>
Ez a példa a következőt fogja kiadni:
Sor(
=> banán
=> alma
=> málna
)
és a $fruit változó értéke "narancs"
PHP 4, PHP 5 által támogatott funkció
array_unshift
Egy vagy több értéket ad egy tömb elejéhez.
Szintaxis:
int array_unshift(lista arr, vegyes var1 [,vegyes var2, ...])
Az array_unshift() függvény hozzáadja az átadott var értékeket az arr tömb elejéhez. Az új elemek sorrendje a tömbben megmarad. A tömb összes digitális indexe úgy módosul, hogy az nulláról induljon. A tömb összes karakterlánc-indexe változatlan.
A függvény a tömb elemeinek új számát adja vissza.
Példa az array_unshift() függvény használatára:
array_unshift($queue, "alma", "málna");
?>
A $queue változónak most a következő elemei lesznek:
Sor(
=> alma
=> málna
=> narancs
=> banán
)
PHP 4, PHP 5 által támogatott funkció
array_unique
Eltávolítja az ismétlődő értékeket egy tömbből.
Szintaxis:
Array array_unique(tömb tömb)
Az array_unique() függvény egy tömböt ad vissza, amely az arr tömbben található összes egyedi értékből áll, a kulcsokkal együtt, az ismétlődő értékek eltávolításával. Az eredményül kapott tömb tartalmazza az elsőként talált kulcs=>érték párokat. Az indexek mentésre kerülnek.
Példa az array_unique() függvény használatára:
"zöld", "piros", "b" =>
"zöld", "kék", "piros");
print_r($eredmény);
?>
A példa a következőt fogja kiadni:
Sor(
[a] => zöld
=> piros
=> kék
)
array_unique() példa: Adattípusok összehasonlítása
$eredmény = array_unique($bemenet);
var_dump($eredmény);
?>
A példa a következőt fogja kiadni:
Tömb(2) (
=> int(4)
=> string(1) "3"
}
Funkciók által támogatott PHP 4 >= 4.0.1, PHP 5
array_chunk
A függvény részekre osztja a tömböt.
Szintaxis:
Array array_chunk(tömb tömb, int méret [, logikai megőrzési_kulcsok])
Az array_chunk() függvény az eredeti tömböt több tömbre bontja, amelyek hosszát a szám mérete adja meg. Ha az eredeti tömb mérete nem pontosan osztható méretrészekkel, akkor az utolsó tömb mérete kisebb lesz.
Az array_chunk() függvény egy többdimenziós tömböt ad vissza, amelynek indexei 0-tól kezdődnek a kapott tömbök számáig, és amelynek értékei a kapott tömbök.
Az opcionálismegőrzés_kulcsok paraméter határozza meg, hogy meg kell-e őrizni az eredeti tömb kulcsait vagy sem. Ha ez a paraméter false (alapértelmezett érték), akkor az eredményül kapott tömbök indexei nullától kezdődő számokra lesznek beállítva. Ha a paraméter igaz, akkor az eredeti tömb kulcsai megmaradnak.
Példa az array_chunk() függvény használatára:
$array = array("1. elem",
"2. elem",
"3. elem",
"4. elem",
"5. elem");
print_r(array_chunk($tömb, 2));
print_r(tömb_csonk($tömb, 2, IGAZ));
A példa a következőt fogja kiadni:
Sor(
=> tömb
=> 1. elem
=> 2. elem
)
=> tömb
=> 3. elem
=> 4. elem
)
=> tömb
=> 5. elem
)
)
Sor(
=> tömb
=> 1. elem
=> 2. elem
)
=> tömb
=> 3. elem
=> 4. elem
)
=> tömb
=> 5. elem
)
Funkciók által támogatott PHP 4 >= 4.2.0, PHP 5
array_fill
A függvény kitölt egy tömböt bizonyos értékekkel.
Szintaxis:
Array array_fill(int start_index, int num, vegyes érték)
Az array_fill() függvény egy tömböt ad vissza, amely a dimenzió num értékparaméterében megadott értékeket tartalmazza, a start_index paraméterben megadott elemtől kezdve.
Példa az array_diff_uassoc() használatával:
print_r($a);
?>
A példa a következőt fogja kiadni:
Sor(
=> banán
=> banán
=> banán
=> banán
=> banán
=> banán
)
Funkciók által támogatott PHP 4 >= 4.2.0, PHP 5
array_filter
A függvény szűrőt alkalmaz egy tömbre egy felhasználó által definiált függvény segítségével.
Szintaxis:
Array array_filter(tömbbemenet [, visszahívás])
Az array_filter() függvény egy tömböt ad vissza, amely a bemeneti tömb értékeit tartalmazza az egyéni visszahívási függvény eredményeinek megfelelően szűrve.
Ha a bemeneti bemeneti tömb egy asszociatív tömb, akkor az indexeket a rendszer a kapott tömbben tárolja.
Példa az array_filter() függvény használatára:
return ($var % 2 == 1);
}
függvény páros($var) (
return ($var % 2 == 0);
}
$tömb1 = tömb("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$tömb2 = tömb(6, 7, 8, 9, 10, 11, 12);
echo "Odd:n";
print_r(tömb_szűrő($tömb1, "páratlan"));
echo "Even:n";
t_r(tömb_szűrő($tömb2, "páros"));
?>
A példa a következőt fogja kiadni:
Páratlan: Array(
[a] => 1
[c] => 3
[e] => 5
Páros: Array(
=> 6
=> 8
=> 10
=> 12
)
Érdemes megjegyezni, hogy a szűrési függvény neve helyett megadhat egy tömböt, amely az objektumra való hivatkozást és a metódus nevét tartalmazza.
Azt is érdemes megjegyezni, hogy egy tömb array_filter() függvénnyel történő feldolgozásakor nem módosítható: adjunk hozzá, távolítsunk el elemeket vagy állítsuk vissza a tömböt, mert ez a funkció hibás működését okozhatja.
Funkciók által támogatott PHP 4 >= 4.0.6, PHP 5
Fontolja meg, hogyan írhat értékeket egy tömbbe. Egy meglévő tömb módosítható az értékeinek explicit beállításával. Ez úgy történik, hogy értékeket rendelünk egy tömbhöz.
A tömbelem-hozzárendelési művelet ugyanúgy néz ki, mint a változó-hozzárendelési művelet, kivéve a tömbváltozó neve után hozzáadott szögletes zárójeleket (). A szögletes zárójelek az elem indexét/kulcsát jelzik. Ha nincs megadva index/kulcs, a PHP automatikusan a legkisebb üres numerikus indexet választja.
"nulla", 1 => "egy"); $my_arr = "kettő"; $my_arr = "három"; var_dump($my_arr); // hozzárendelés index/kulcs nélkül $my_arr = "négy"; $my_arr = "öt"; visszhang"
"; var_dump($my_arr); ?>
Egy adott érték megváltoztatásához csak új értéket kell rendelnie egy már meglévő elemhez. Egy tömb bármely elemének eltávolításához indexével/kulcsával, vagy magának a teljes tömbnek az eltávolításához használja az unset() függvényt:
Megjegyzés: mint fentebb említettük, ha egy elemet kulcs megadása nélkül adunk hozzá egy tömbhöz, a PHP automatikusan az egész típusú kulcs előző legnagyobb értékét fogja használni, plusz 1-et. Ha még nincsenek egész indexek a tömbben, akkor a kulcs legyen 0 (nulla).
Vegye figyelembe, hogy a kulcs legnagyobb egész értéke jelenleg nem feltétlenül létezik a tömbben, ennek oka lehet a tömbelemek eltávolítása. Az elemek eltávolítása után a tömb nem indexelődik újra. Vegyük a következő példát, hogy világosabb legyen:
"; print_r($my_arr); // Elem hozzáadása (vegye figyelembe, hogy az új kulcs 3 lesz 0 helyett). $my_arr = 6; echo "
"; print_r($my_arr); // Újraindexelés: $my_arr = array_values($my_arr); $my_arr = 7; echo "
"; print_r($my_arr); ?>
Ez a példa két új függvényt használt, a print_r() és az array_values() függvényt. Az array_values() függvény egy indexelt tömböt ad vissza (újraindexeli a visszaadott tömböt numerikus indexekkel), a print_r függvény pedig úgy működik, mint a var_dump , de olvashatóbb módon adja ki a tömböket.
Most megfontolhatjuk a tömbök létrehozásának harmadik módját:
A példa egy harmadik módszert mutatott be egy tömb létrehozására. Ha a $weekdays tömb még nem jött létre, akkor létrejön. Ez a fajta tömb létrehozása azonban nem ajánlott, mert ha a $weekdays változó már létrejött és értéket tartalmaz, az váratlan szkripteredményekhez vezethet.
Ha kétségei vannak azzal kapcsolatban, hogy egy változó tömb-e, használja az is_array függvényt. Például az ellenőrzést a következőképpen lehet elvégezni:
"; $no = "sima karakterlánc"; echo is_array($no) ? "Tömb" : "Nem tömb"; ?>
PHP támogatja a skaláris és kompozit adattípusokat. Ebben a cikkben az egyik összetett típust tárgyaljuk: a tömböket. A tömb olyan adatértékek gyűjteménye, amelyek kulcs-érték párok rendezett halmazaként vannak rendezve.
Ez a cikk egy tömb létrehozásáról és elemek tömbhöz való hozzáadásáról szól. Számos beépített függvény működik a tömbökkel php, mert a tömbök gyakoriak és hasznosak. Például, ha egynél több e-mail címre szeretne e-mailt küldeni, akkor az e-mail címeket egy tömbben tárolhatja, majd a tömbön keresztül a tömbben lévő e-mail címre küldheti az üzeneteket.
Indexelt és asszociatív tömbök
A PHP-ben kétféle tömb létezik: indexelt és asszociatív. Az indexelt tömb kulcsai 0-tól kezdődő egész számok. Az indexelt tömbök akkor használatosak, ha egy tömbben egy adott pozícióra van szükség. Az asszociatív tömbök úgy viselkednek, mint egy táblázat két oszlopa. Az első oszlop az érték eléréséhez használt kulcs (a második oszlop).
PHP belsőleg az összes tömböt asszociatív tömbként tárolja, így az asszociatív és az indexelt tömbök között csak az a különbség, hogy a kulcsok megjelennek. Egyes függvények elsősorban indexelt tömbökhöz használhatók, mivel azt feltételezik, hogy a kulcsok egymást követő, 0-tól kezdődő egész számok. Mindkét esetben a kulcsok egyediek, vagyis nem lehet két elem ugyanazzal a kulccsal, függetlenül attól, hogy a kulcs egy karakterlánc vagy egész szám.
NÁL NÉL PHP a tömbök elemeinek belső sorrendje kulcsoktól és értékektől független, és vannak olyan függvények, amelyekkel e belső sorrend alapján lehet bejárni a tömböket.
Elemek meghatározása egy tömbben
Egy tömbből konkrét értékeket érhet el, ha a tömb nevét követi az elemkulcs (ezt néha indexnek is nevezik) szögletes zárójelben:
$age["Fred"]; $shows;
A kulcs lehet karakterlánc vagy egész szám. A számok formájában lévő karakterlánc-értékeket (bevezető nullák nélkül) egész számként kezeljük. Ily módon $tömbés $tömb['3'] ugyanarra az elemre utalnak, de $tömb['03'] egy másik elemre utal. A negatív számok is használhatók kulcsként, de nem adnak meg pozíciókat a tömb végétől, mint pl. perl.
A kulcsot nem szükséges idézőjelbe írni. Például, $array['Fred'] tetszik $arrat. Ennek ellenére jó stílusnak tartják. PHP mindig használjon idézőjeleket. Ha az index nem idézőjel, akkor a PHP a konstans értékét használja indexként:
define("index",5); echo $tömb; // a $tömböt adja vissza, nem a $tömböt["index"];
Ha egy számot szeretne behelyettesíteni az indexbe, akkor ezt kell tennie:
$age["Klón$szám"]; // visszaadja, például $age["Clone5"];
A kulcsot azonban ne idézze a következő esetekben:
// rossz nyomtatás "Hello, $person["name"]"; print "Hello, $person["név"]"; // helyes nyomtatás "Hello, $person";
Adatok tárolása tömbökben
Amikor megpróbál értéket tárolni egy tömbben, akkor a rendszer automatikusan létrehoz egy tömböt, ha korábban nem létezett, de ha nem definiált tömbből próbál lekérni egy értéket, akkor a tömb nem jön létre. Például:
// A $addresses eddig nem lett meghatározva echo $addresses; // semmi echo $címek; // semmi $addresses = "spam@cyberpromo.net"; echo $címek; // "Array" nyomtatása
Egyszerű hozzárendeléssel inicializálhat egy tömböt a programban:
$addresses = "spam@cyberpromo.net"; $címek = "abuse@example.com"; $címek = "root@example.com"; // ...
Deklaráltunk egy indextömböt 0-tól kezdődő egész indexekkel.
Asszociatív tömb:
$ár["Tömítés"] = 15,29; $ár["kerék"] = 75,25; $ár["Abroncs"] = 50,00; // ...
Egy tömb inicializálásának egyszerűbb módja a konstrukció használata sor(), amely egy tömböt épít fel argumentumaiból:
$címek = array("spam@cyberpromo.net", "abuse@example.com", "root@example.com");
Asszociatív tömb létrehozásához azzal sor(), használat => az indexeket az értékektől elválasztó karakterek:
$ár = array("Tömítés" => 15,29, "Kerék" => 75,25, "Abroncs" => 50,00);
Ügyeljen a szóközhasználatra és az igazításra. Csoportosíthatnánk a kódot, de kevésbé lenne leíró:
$ár = array("Tömítés"=>15.29,"Kerék"=>75.25,"Gumi"=>50.00);
Üres tömb létrehozásához meg kell hívni a konstrukciót sor()érvek nélkül:
$címek = array();
Megadhat egy kezdőkulcsot egy tömbben, majd egy értéklistát. Az értékek a tömbbe kerülnek, a kulccsal kezdve, majd növelve:
$days = array(1 => "hétfő", "kedd", "szerda", "csütörtök", "péntek", "szombat", "vasárnap"); // A 2 a kedd, a 3 a szerda stb.
Ha a kezdő index egy karakterlánc, akkor a következő indexek 0-tól kezdődő egész számokká válnak. Tehát a következő kód valószínűleg hiba:
$whoops = array("Péntek" => "Fekete", "Barna", "Zöld"); // ugyanaz, mint a $whoops = array("Friday" => "Fekete", 0 => "Barna", 1 => "Zöld");
Új elem hozzáadása egy tömb végéhez
Ha több értéket szeretne beszúrni egy meglévő indexelt tömb végére, használja a következő szintaxist:
$család = array("Fred", "Wilma"); // $family = "Fred" $family = "Kavicsok"; // $family = "Pebbles"
Ez a konstrukció feltételezi, hogy a tömb indexei számok, és hozzárendeli az elemhez a következő elérhető numerikus indexet, 0-tól kezdve. Az, hogy megpróbálunk elemet hozzáadni egy asszociatív tömbhöz, szinte mindig programozói hiba, de PHP figyelmeztetés nélkül új elemeket ad hozzá a numerikus indexekhez (0-tól kezdve):
$person = array("név" => "Fred"); // $person["name"] = "Fred"; $személy = "Wilma"; // $person = "Wilma"
Ebben a szakaszban befejezzük a PHP tömbökkel való munka bevezető részét. Várom, hogy találkozzunk a következő cikkben.