Pole si můžeme představit jako množinu dat, které vzájemně nějak souvisí. Například abeceda, skupina čísel, názvy ovoce, skupina žáků ve třídě apod. Jedná se o prostředek pro hromadné zpracování dat. Jinak řečeno, pole je místem, do kterého můžeme uskladnit libovolné množství dat. A to do slova. Tedy velikost pole je závislá pouze na velikosti dostupných prostředků počítače (velikost paměti, databáze…).
Vytváření pole
Pole se vytváří za pomoci konstrukce array. Příklad:
<?php
$cisla = array(1,2,3);
// Vytvoření pole, do kterého budou uložena tři čísla: jednička, dvojka a trojka.
var_dump($cisla);
// Vypsání celého pole. Výpis bude vypadat takto: // array(3) { [0]=> int(1) [1]=> int(2) [2]=> int(3) }
?>
V poli můžeme používat i různé kombinace datových typů, např. místo dvojky můžete vložit text „dvojka“ (vyzkoušejte si to).
Práce se záznamy v poli
Se záznamy v poli se dá různě pracovat.
1. Sečtení počtu záznamů v poli
Pro sečtení celkového počtu záznamů v poli existuje jednoduchá funkce count. Příklad:
<?php $pole = array(10,20,30,40); // Vytvoření pole, do kterého budou uložena čtyři čísla $pocet = count($pole); // Funkce count zde zjišťuje počet údajů v poli $pole. Protože pole $pole obsahuje čtyři údaje, funkce count vrátí čtyřku. Proměnná $pocet tedy bude obsahovat čtyřku. echo $pocet; // Vypíše: 4 ?>
Tato funkce se velmi často používá. Příklad – vypsání celkového počtu záznamů v návštěvní knize, celkový počet záznamů ve fotogalerii apod.
2. Hledání v poli
Aby bylo možné se záznamy v poli pracovat, je nutné, aby byl každý záznam nějak identifikovatelný (každý záznam má své pojmenování). To se děje vlastně automaticky a to tak, že každý ze záznamů má podle toho jak byl do pole uložen své pořadí. V PHP tomu říkáme index. Pořadí či index je v PHP (ale i v jiných prog. jazycích) počítáno od nuly. Tedy první záznam má index nula druhý jedna, třetí dva atd… Příklad:
$pole = array(10,20,30,40); //desítka má index nula, dvacítka má index jedna, třicítka má index dva…
Pro práci s indexi používá PHP hranatých závorek. Např. – [2] (klávesová zkratka pravý Alt+F a G)
Příklad:
<?php $pole = array(10,20,30,40); // Vytvoření pole, do kterého budou uložena čtyři čísla var_dump($pole[1]); // Vypíše: int(20), ?>
3. Změny záznamů v poli
Velmi jednoduchým způsobem můžeme také jednotlivé záznamy v poli měnit. Příklad:
<?php
$pole = array(1,2,3,4,5);
// Vytvoření pole, ve kterém bude uloženo pět čísel. Jednička má index nula, dvojka má index jedna, trojka má index dva, čtyřka mí index tři a pětka má index čtyři.
var_dump($pole);
// Vypíše celé array(5) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(4) [4]=> int(5) }
echo '<br>';
//další záznamy budou na novém řádku
$pole[3] = 10;
// Změna prvku v poli, který má index tři. Na tomto indexu byla původně čtyřka, teď jsme tam uložili namísto ní desítku. Pole teď vlastně obsahuje čísla: 1,2,3,10,5.
var_dump($pole);
// Vypíše array(5) { [0]=> int(1) [1]=> int(2) [2]=> int(3) [3]=> int(10) [4]=> int(5) }
?>
4. Přidávání nových prvků do pole
Pokud do pole potřebujeme přidat nový záznam, máme k dispozici dva způsoby – přidání nového záznamu automaticky, tedy na konec pole nebo tak, že rovnou napíšeme, jáký index záznamu dáváme. Příklad, kdy vytváříme nový index 2 a do něj vkládáme hodnotu 30:
<?php
$pole = array(1 => 20, 3 => 40, 6 => 70);
// Vytvoření pole, ve kterém budou uložena tři čísla
echo $pole[1];
// Vypíše: 20, protože index 1 má číslo 20
$pole [2] = 30;
// Vytvoření záznamu s indexem 2 a vložení čísla 30 do tohoto indexu
var_dump ($pole);
// Vypíše: 20array(4) { [1]=> int(20) [3]=> int(40) [6]=> int(70) [2]=> int(30) }
?>
Všimněte si, že nový záznam je vypsán až jako poslední i když to neodpovídá číselné posloupnosti.
Druhým způsobem je vkládání nového záznamu bez udání indexu. Stačí vložit jen prázdné hranaté závorky:
<?php
$pole = array(1 => 20, 3 => 40, 6 => 70);
// Vytvoření pole, ve kterém budou uložena tři čísla
echo $pole[1];
// Vypíše: 20, protože index 1 má číslo 20
$pole [] = 30;
// Vytvoření záznamu s indexem 7 a vložení čísla 30 do tohoto indexu
var_dump ($pole);
// Vypíše: 20array(4) { [1]=> int(20) [3]=> int(40) [6]=> int(70) [7]=> int(30) }
?>
V tomto případě se PHP podívá na největší existující index a nově vkládanému přiřadí index o číslo větší. Tedy v tomto případě 7.
5. Ovlivňování indexů
Indexy v poli můžeme i my sami ovlivnit a to zápisem:
index => hodnota
PHP neklade žádná omezení, indexy můžete tvořit i napřeskáčku. Např.:
<?php $pole = array(7 => 20, 6 => 30); // Vytvoření pole, ve kterém budou uložena dvě čísla, a to dvacítka a třicítka. // Index 5 má dvacítka a index 6 má třicítka. echo $pole[6]; // Vypíše: 30 ?>
6. Řetězce jako indexy
Indexy můžeme mít i v podobě textových řetězců. Příklad:
<?php
$pole = array('jednička' => 1, 'dvojka' => 2);
// Vytvoření pole, ve kterém budou uložena dvě čísla, a to jednička a dvojka.
// Index 'jednička' má uloženo číslo 1 a index 'dvojka' má uloženo číslo 2.
echo $pole['jednička'];
// Vypíše: 1
?>
Mezi indexem pro který je použito celé číslo a indexem, pro nějž je použit řetězec není v principu (z hlediska práce s ním) žádný rozdíl.
7. Procházení polí
Pro procházení polí se používá většinou funkce foreach. Existují ještě jiné funkce, ale ty se používají jen velmi zřídka (např. next() a prev()). Funkce (nebo také konstrukce) foreach je vlastně cyklus, který prochází všemi prvky pole a pro každý z nich provede nějakou činnost. Např. jej vypíše. Zjednodušeně to vypadá takto:
foreach (pole as proměnná_pro_každý_prvek_pole) příkaz_který_se_provede_pro_každý_prvek_pole;
Ve skutečnosti to vypadá následovně:
<?php $pole = array(1,2,3); // Vytvoření pole, které obsahuje tři čísla. foreach ($pole as $hodnota) echo 'Nalezen prvek s hodnotou: ',$hodnota,'<br>'; // Konstrukce foreach, která prochází pole $pole a hodnotu každého prvku tohoto pole vypíše. ?>
Této konstrukci říkáme procházení bez indexu. Další variantou je procházení s indexem. Ke stávajícímu příkladu vlastně jen přidáme požadavek na výpis indexu:
<?php $pole = array(1,2,3); // Vytvoření pole, které obsahuje tři čísla. foreach ($pole as $index => $hodnota) echo 'Nalezen prvek s indexem: ',$index,', hodnota: ',$hodnota,'<br>'; // konstrukce foreach, která prochází pole $pole a vypíše jak index daného prvku, tak jeho hodnotu ?>
Pozn.: proměnná $index může mít jakýkoliv název, tedy ne zrovna „index“. To stejné platí pro proměnnou „hodnota“.
8. Prověření existence pole
Abychom zjistili, jestli v nějakém poli existuje určitý prvek, použijeme funkci in_array().
Příklad:
<?php
$jmena = array("Petr", "Jan", "Gustav", "Pavel");
if (in_array("Jan", $jmena))
{
echo "Jan je mezi jmény";
}
else
{
echo "Jan mezi jmény není";
}
?>
9. Přidání a odebrání prvku pole
Přidání na začátek pole
Jak je popsáno výše, pokud přidáme do pole nový prvek, vždy se zařadí na konec – tedy zařadí se jako poslední. Pokud ale chceme, aby se zařadil jako první, můžeme k tomu využít funkci array_unshift(). Příklad:
<?php
$jmena = array("Adam","Bára","Tomas");
echo ($jmena[0]." ".$jmena[1]." ".$jmena[2]);
echo "<br>";
array_unshift($jmena,"Karel");
echo ($jmena[0]." ".$jmena[1]." ".$jmena[2]);
?>
V tomto příkladu vidíte, že na počátku má pozici 0 v poli jméno Adam. Po přidání nového jména Karel se toto jméno zařadí funkcí array_unshift na začátek, tedy místo jména Adam. Ostatní prvky pole se posunou.
Odebrání prvního prvku pole
Pokud použijeme funkci array_shift, pak se naopak první prvek v poli smaže a ostatní prvky pole se posunou o pozici vpřed:
<?php
$jmena = array("Adam","Bára","Tomas");
echo ($jmena[0]." ".$jmena[1]." ".$jmena[2]);
echo "<br>";
array_shift($jmena);
echo ($jmena[0]." ".$jmena[1]);
//pozice 2 není vypsána, protože neexistuje a skript by vypsal chybu
?>
Přidání na konec pole
Velmi podobně se používá funkce array_push:
<?php $jmena = array(1 => "Adam", 3 => "Dan", 6 => "Karel"); print_r($jmena); echo "<br>"; array_push($jmena,"Hana"); print_r($jmena); ?>
Odebrání prvku z konce pole
Pokud potřebujeme odebrat poslední prvek pole, použijeme funkci array_pop:
<?php $jmena = array(1 => "Adam", 3 => "Dan", 6 => "Karel"); print_r($jmena); echo "<br>"; array_pop($jmena); print_r($jmena); ?>
10. Přidání a odebrání více prvků pole
Rozšíření pole
Pomocí funkce array_pad můžeme prvky pole rozšířit jak na začátku (záporné hodnoty), tak na konci (kladné hodnoty). Tato funkce má však 3 parametry. Syntaxe funkce:
array_pad(pole, množství, prvky)
Jako množství se udává celkový počet prvků, které bude pole tvořit po přidání. Parametr prvky je hodnota, která bude do celkového počtu vytvořena na zbývajících indexech pole. Příklad:
<?php
$jmena=array("Adam","Dan","Karel");
print_r(array_pad($jmena,6,"Vaclav"));
?>
Výsledkem bude, že celkový počet prvků v poli bude 6 a poslední 3 budou mít stejnou hodnotu – Václav.
Načtení prvků
Hromadně můžeme načíst prvky pole za pomoci funkce array_slice. Tato funkce má 4 parametry:
array_slice(pole, pozice, délka, zachování indexů)
Pozice znamená číslo indexu, od kterého se mají začít načítat hodnoty prvků. Délka je nepovinný údaj. Pokud se uvede, znamená to počet indexů, které se mají od pozice načíst. V případě, že není uvedena, načtou se všechny prvky až do konce. Zachování indexů je parametr, který má dvě hodnoty – false nebo true. Pokud použijeme ano, tedy true, zachovají se původní hodnoty indexů daných prvků. Hodnota false je defaultní a je zbytečné ji udávat. Znamená to tedy, že nově vytvořený seznam prvků má novou (svoji) indexaci:
<?php
$jmena=array("Adam","Dan","Karel","Bára","Josef", "Tomáš");
print_r(array_slice($jmena,2,2));
//načetli jsme prvky od pozice 2 v počtu 2. Indexy jsou vytvořeny znovu.
echo "<br>";
print_r(array_slice($jmena,2,2,true));
//načetli jsme prvky od pozice 2 v počtu 2. Indexy se zachovaly z původního číslování pole.
?>
Nahrazení prvků
Pro nahrazování prvků pole se používá funkce array_splice. Základní syntaxe:
array_splice(pole, pozice, délka, nahrazující prvek)
Nahrazení je provedeno tak, že se od pozice XY (parametr pozice – např. od pozice 2) v délce XY (délka je počet indexů – např. 3) nahradí prvky původního pole nahrazujícími prvky (většinou definované v proměnné).
<?php
$jmena=array("Adam","Dan","Karel","Bára","Josef", "Tomáš");
print_r($jmena);
echo "<br>";
$jmena2=array("David","Petr","Jan");
array_splice($jmena,2,3,$jmena2);
//Jména Karel a Bára budou nahrazeny novými jmény David, Petr a Jan
//Jedná se o pozice od č.2 v počtu 3. Nová jména jsou načítána z proměnné jmena2
print_r($jmena);
?>
Odstranění prvků
Odstranění prvků se provede stejnou funkcí, jen vynecháme nahrazující prvek:
<?php
$jmena=array("Adam","Dan","Karel","Bára","Josef", "Tomáš");
print_r($jmena);
echo "<br>";
print_r(array_splice($jmena,2,3));
echo "<br>Výsledek po odstranění: ";
print_r($jmena);
?>
V tomto případě budou od pozice 2 (včetně) odstraněny 3 prvky. Zbytek zůstává beze změn, jen zachované prvky změní svůj index (v příkladu dostane jméno Tomáš nově index č. 2).
Převedení pojmenovaných indexů na číselné
Pokud máme pole, kde máme jednotlivé indexy pojmenované (asociativní pole), můžeme si je jednoduše převést na defaultní – číselné hodnoty funkcí array_values:
<?php
$seznam=array("Jméno"=>"Petr","Věk"=>"41","Bydliště"=>"Znojmo");
print_r(array_values($seznam));
//Výsledek - Array ( [0] => Petr [1] => 41 [2] => Znojmo )
?>
Převedení pojmenování indexů na jednotlivé prvky
Pokud jsou jednotlivé indexy pojmenované a tyto názvy potřebujeme dostat do pole jako jednotlivé prvky, použijeme funkci array_keys:
<?php
$auta=array("Volvo"=>"XC90","BMW"=>"X5","Toyota"=>"Highlander");
print_r(array_keys($auta));
//Výsledkem je Array ( [0] => Volvo [1] => BMW [2] => Toyota )
?>
Tato funkce má ještě další dva volitelné parametry – hodnota (value) a kontrola typu (strict). První příklad ukazuje hledání hodnoty indexu čísla „15“ bez kontroly typu:
<?php $cisla=array(15,25,35,45,"15"); print_r(array_keys($cisla,"15")); //Výsledek je Array ( [0] => 0 [1] => 4 ) //Skript našel číslo 15 na pozici 0 a na pozici 4 ?>
Druhý příklad ukazuje hledání hodnoty indexu čísla „15“ s kontrolou datového typu. A protože hledaný výraz „15“, tedy číslo, uvedené v uvozovkách není číslem, ale textovým řetězcem, není nalezeno na pozici 0, ale jen na pozici 4:
<?php $cisla=array(15,25,35,45,"15"); print_r(array_keys($cisla,"15",true)); //Výsledek je Array ( [0] => 4 ) //Skript našel výraz "15" pouze na pozici 4. Nově má index 0 ?>
Záměna hodnot a indexů
Funkcí array_flip zaměníme hodnoty prvků a indexy:
<?php
$pole1=array("a"=>"červená","b"=>"zelená","c"=>"modrá","d"=>"žlutá");
$zmena=array_flip($pole1);
print_r($zmena);
//Výsledek - Array ( [červená] => a [zelená] => b [modrá] => c [žlutá] => d )
?>
Obrácené pořadí prvků
Funkce array_reverse slouží k obrácení pořadí prvků v poli:
<?php
$auta=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
print_r(array_reverse($auta));
//Výsledek - Array ( [c] => Toyota [b] => BMW [a] => Volvo )
?>
Sdružení (sloučení) polí
Na sloučení polí používáme funkci array_merge. Pozor u asociativních (pojmenovaných) indexů – zde mohou nastat chyby.
<?php
$pole1=array("červená","zelená");
$pole2=array("modrá","žlutá");
print_r(array_merge($pole1,$pole2));
//Výsledek - Array ( [0] => červená [1] => zelená [2] => modrá [3] => žlutá )
?>
PHP disponuje mnoha dalšími funkcemi na práci v poli. Další informace o polích v PHP najdete např. na webu itnetwork.cz nebo např. na w3schools.com
