- Takto funkce patří mezi mé oblíbené a rozděluje text na kousky, podle delimiteru.
- Delimiter je většinou nějaký znak, podle kterého se text nebo-li string rozděluje.
- Kousky rozděleného textu se převádí na pole.
- Pojďme se tedy podívat na příkaz explode(), který má 3 parametry.
- První parametr je delimiter, druhý text a třetí parametr určuje počet rozdělění.
$text = "rajce,hruska,svetska,oliva,meloun"; // nejaky text oddeleny carkami
$slova = explode(',', $text); // podle carek se slova pridaji do pole
echo $slova[2]; // vypise: "svestka"
- Pole bude tedy vypadat nějak takto:
array 0 => string 'rajce' 1 => string 'hruska' 2 => string 'svetska' 3 => string 'oliva' 4 => string 'meloun'- Ještě ukázka se třetím parametrem.
$text = "rajce,hruska,svetska,oliva,meloun";
$slova = explode(',', $text, 3); // vezme prvni 2 slova a zbytek spoji do jednoho
- V tomto případě pole bude vypadat takto:
array 0 => string 'rajce' 1 => string 'hruska' 2 => string 'svetska,oliva,meloun'
- Tyto funkce jsou naprostým opakem funkce explode().
- I když jsou naprosto stejné, tak budeme používat spíše první variantu, protože je používanější i známější.
- Takže tedy funkce implode() má 2 parametry, kde první je glue (opak delimiteru). Je to vlastně znak nebo slovo, které bude spojovat jednotlivé prvky pole.
- Jednoduše dělá to, že spojí všechny prvky pole do jednoho textu a pomocí glue je spojí.
$pole = array("hruska", "malina", "jahoda", "granat");
$text = implode('-', $pole);
echo $text; // vypise: "hruska-malina-jahoda-granat"
- Tady není moc co řešit. Jen ještě uvedu, že tuto funkci lze zadat i s jedním parametrem - pouze pole.
$pole = array("hruska", "malina", "jahoda", "granat");
$text = implode($pole);
echo $text; // vypise: "hruskamalinajahodagranat"
- Tato funkce je debugovací, to znamená, že se nepoužívá běžně v projektech, ale jen jako debug - třeba při tvorbě webu.
- Funkce print_r() vrací informace o vstupu a má 2 parametry, kde první je vstup něčeho a
druhý mění výstup z return na echo a obráceně (výchozí je false = echo).
$pole = array("hruska", "malina", "jahoda", "granat"); // nejake pole
// vypise: "Array ( [0] => hruska [1] => malina [2] => jahoda [3] => granat )"
print_r($pole);
print_r($pole, true); // nevypise nic, protoze vraci return
echo print_r($pole, true); // vypise to same, jako prvni priklad
- Další příklad se třídou.
class T
{
public $a = 10;
protected $b = 20;
private $c = 30;
static $d = 40;
}
// vypise: "T Object ( [a] => 10 [b:protected] => 20 [c:T:private] => 30 )"
print_r(new T);
- Statickou proměnnou to neukáže, protože se k ní nepřistupuje přes objekt.
- Tato funkce var_dump() je též debugovací, ale oproti print_r() je novější a lze u ní použít nespočet parametrů.
Není tak limitovaná na testování pouze jednoho parametru, jako předchozí funkce.
- Má i trochu jiný a detailnější výpis.
class T
{
public $a = 10;
protected $b = 20;
private $c = 30;
static $d = 40;
}
/* vypise:
* object(T)[2]
* public 'a' => int 10
* protected 'b' => int 20
* private 'c' => int 30
*/
var_dump(new T);
- Jak jsem řekl, tak funkce má nespočet parametrů. Každý další parametr se oddělí čárkou.
class Bagr
{
public $promenna = 500;
}
$pole = array("ahoj", "svete", 23, array(1,2,3));
$dalsiPole = array("jedna" => 1, "dva" => 2);
$cislo = 100;
var_dump(new bagr, $pole, $dalsiPole, $cislo);
- A výstup z funkce bude:
// pro vytvoreni tridy Bagr
object(Bagr)[2]
public 'promenna' => int 500
// pro pole - $pole
array
0 => string 'ahoj' (length=4)
1 => string 'svete' (length=5)
2 => int 23
3 =>
array
0 => int 1
1 => int 2
2 => int 3
// pro pole - $dalsiPole
array
'jedna' => int 1
'dva' => int 2
// promenna $cislo
int 100
Dodatek: Pokud by vám tato funkce nevyhovovala a máte radší funkci print_r(), tak doporučim jeste funkci var_export(),
která je naprosto totožná s funkcí print_r(), ale má výhody funkce var_dump(). To znamená, že funkce má 2 parametry a výstup je detailnější.
- Zjišťuje, zda vstup je typ array (pole) a vrací true nebo false.
$pole = array(1,2,3); echo (is_array($pole)) ? "je" : "není";
- Zjišťuje, zda vstup je typ bool a vrací true nebo false.
$clovek = true; echo (is_bool($clovek)) ? "je" : "není";
- Zjišťuje, zda vstup je typ float nebo double a vrací true nebo false.
- Mezi těmito funkcemi není v PHP žádný rozdíl, takže je jen na vás, kterou použijete.
$cislo = 10.5; echo (is_float($cislo)) ? "je" : "není"; echo (is_double($cislo)) ? "je" : "není"; echo (is_real($cislo)) ? "je" : "není";
- Zjišťuje, zda vstup je typ int a vrací true nebo false.
- Opět to samé. Tyto funkce je naprosto totožné.
- PHP nemá typ long, takže to spadá do int.
$cislo = 8; echo (is_int($cislo)) ? "je" : "není"; echo (is_integer($cislo)) ? "je" : "není"; echo (is_long($cislo)) ? "je" : "není";
- Zjišťuje, zda vstup je typ null (žádný) a vrací true nebo false.
$nic = null; echo (is_null($nic)) ? "je" : "není";
- Zjišťuje, zda vstup je číslo, ať ve formě čísla nebo stringu a vrací true nebo false.
$a = 5; $b = 4.6; $c = "8"; $d = "8e2"; // 800 (je cislo) $e = "8x"; // neni cislo $e = "0x8"; // je cislo echo (is_numeric($a)) ? "je" : "není"; echo (is_numeric($b)) ? "je" : "není"; echo (is_numeric($c)) ? "je" : "není"; echo (is_numeric($d)) ? "je" : "není"; echo (is_numeric($e)) ? "je" : "není"; // není echo (is_numeric($f)) ? "je" : "není";- Zápis 8e2 možná neznáme, to e je exponent. A zápis 0x8 je hexadecimální.
- Zjišťuje, zda vstup je typ object a vrací true nebo false.
class Trida { }
$obj = new Trida();
echo (is_object($obj)) ? "je" : "není";
- Zjišťuje, zda vstup je typ resource a vrací true nebo false.
- Teď nevim, jestli jsem tento typ zmiňoval. No, řeknu to stručně. Tento typ vrací třeba otevření souboru nebo připojení k mysql serveru.
My zatím známe jen práci se souborem, takže třeba fopen() vrací typ resource.
$file = fopen("soubor.txt", "r"); // rekneme, ze soubor existuje, jinak vrati false
echo (is_resource($file)) ? "je" : "není";
- Zjišťuje, zda vstup patří mezi typy int, float, double, string a bool a vrátí true nebo false.
$file = fopen("soubor.txt", "r"); // soubor nebude existovat
$cislo = 10;
$druheCislo = 5.9;
$text = "svet";
$spravne = true;
echo (is_scalar($file)) ? "je" : "není"; // vrati JE
echo (is_scalar($cislo)) ? "je" : "není";
echo (is_scalar($druheCislo)) ? "je" : "není";
echo (is_scalar($text)) ? "je" : "není";
echo (is_scalar($spravne)) ? "je" : "není";
Pozor: Pokud nějaká vaše funkce nebo PHP funkce vrátí při neúspěchu false, jako třeba fopen(), tak je to bráno jako scalar, i když může běžně vracet úplně jinej typ!
- Zjišťuje, zda vstup je typ string (text) a vrací true nebo false.
$text = "svet"; echo (is_string($text)) ? "je" : "není";
- Zjišťuje, zda vstup je nekonečno - INF (hodnota) a vrací true nebo false.
- Nekonečno sice neznáme, ale dá se předpokládat, že tohle je obrovská float hodnota.
- Tato zkratka znamená - INFinite.
$nekonecno = INF; echo (is_infinite($nekonecno)) ? "je" : "není";
- Zde je stejný případ jako u funkce is_numeric(), ale liší se v tom, že INF se nepovažuje za finální hodnotu.
$nekonecno = INF; // neni finalni $cislo = 12345678901234567890; echo (is_finite($nekonecno)) ? "je" : "není"; // NENI echo (is_finite($cislo)) ? "je" : "není";
- Zjišťuje, zda vstup je nečíslo - NAN (hodnota) a vrací true nebo false.
- Tato zkratna znamená - Not a Number.
$num = NAN; echo (is_nan($num)) ? "je" : "není";
- Tato funkce error_reporting() slouží k úrovni vypisování chybových hlášení z vašeho kódu.
- Má jeden parametr a to level varování.
- Každý chybový kód má svoji konstantu, ale lze zadat i číslo.
- Jinak řečeno, to skrývá vaše chyby na stránce, který kód udělá. Osobně to ale nedoporučuju, dobrý programátor si dokáže vždy ošetřit i ty banální chyby.
- Tato funkce se dává na první řádek, protože se aplikuje na vše, co je pod ní.
echo $e; // vypise notice, ze promenna neexistuje error_reporting(!E_NOTICE); // skryjeme vsechny notice chyby (hlaseni) echo $f; // nevypise nic, i kdyz promenna neexistuje- Nyní si ukážem, jaké všechny kódy chyb lze nastavit.
error_reporting(!E_NOTICE); // budu ignorovat vsechny oznameni error_reporting(!E_WARNING); // budu ignorovat vsechny varovani (to bych moc nedaval) error_reporting(!E_ERROR); // budu ignorovat vsechny fatalni chyby (nikdy nedavejte) // budu ignorovat vsechny mozne chyby, varovani i oznameni error_reporting(NULL); // to same, jako kdybych tam dal 0- Samozřejmě chybové kódy jdou spojovat, pokud bych chtěl zakázat všechny oznámení i varovaní tak dám:
error_reporting(!E_NOTICE | !E_WARNING); // budu ignorovat vsechny oznameni i varovani- Další možnost, jak můžeme ignorovat chybu je pomocí operátoru @, který se dává většinou před funkci nebo proměnnou, kde víme, že tam může vyskočit chyba.
// zde je to sice spatny priklad, protoze fopen vyhazuje varovani, ale pro priklad...
$file = @fopen("log.txt", "r"); // nevypise chybu, pokud soubor nebude neexistovat
// normalne je pouze notice, ze promenna neexistuje
echo @$promenna; // skryji oznameni
- Tato funkce time() vrací unixový čas, který si pomocí jiných funkcí nebo ručně můžete převést na vámi požadovaný.
- Je to vlastně čas v sekundách od roku 1970.
echo time(); // vypise treba: "1310145780"
- Tato funkce formátuje čas a datum podle předlohy, kterou částečně ukážu (zbytek si najděte v manuálu).
- Funkce date() má 2 parametry, kde první je formát času a druhý unixtime (timestamp).
- Pojďme si tedy ukázat pár základních formátovacích značek.
- d - den v měsíci (s nulou) ... 01 - 31
- j - den v měsíci (bez nuly) ... 1 - 31
- z - den v roce (z 365)
- m - měsíc v roce (s nulou) ... 01 - 12
- n - měsíc v roce (bez nuly) ... 1 - 12
- L - zjišťuje, zda se jedná o přestupný rok (1 - ano, 0 - ne)
- Y - současný rok (celý) ... 2011
- y - současný rok (zkrácený) ... 11
- a - zjistí dopoledne nebo odpoledne (malé) ... am / pm
- A - zjistí dopoledne nebo odpoledne (velké) ... AM / PM
- g - 12 hodinový časový formát (bez nuly) ... 1 - 12
- G - 24 hodinový časový formát (bez nuly) ... 1 - 23
- h - 12 hodinový časový formát (s nulou) ... 01 - 12
- H - 24 hodinový časový formát (s nulou) ... 01 - 23
- i - minuty (s nulou) ... 00 - 59
- s - sekundy (s nulou) ... 00 - 59
- u - milisekundy ... 654321
- D - textově dny v týdnu (anglicky - zkráceně) ... Mon - Sun
- l - textově dny v týdnu (anglicky - celé) ... Sunday - Saturday
- M - textově měsíce (anglicky - zkrácené) ... Jan - Dec
- F - textově měsíce (anglicky - celé) ... January - December
- N - vrací číslu dne v týdnu ... 1 = pondělí - 7 = neděle
- c - komplexní formát podle ISO 8601 ... 2011-07-08T22:06:11+02:00
- r - komplexní formát podle RFC 2822 ... Fri, 08 Jul 2011 22:06:11 +0200
- U - vrátí současný unixtime (to samé jako funkce time())
- Formátů je trochu víc, ale ty už nejsou tak používaný jako tyhle.
- Malá ukázka.
echo date('H:m:s'); // 21:07:04
echo date('H\h\o\d m\m\i\n s\s\e\c'); // 21hod 07min 04sec
echo date('Y'); // 2011
echo date('d.m.Y - H:m:s'); // 08.07.2011 - 21:07:26
- Jak už jsem řekl, tak datum nebo čas si lze složit i z unixového času (druhý parametr).
echo date('d.m.Y - H:m:s', 1273486210); // 10.05.2010 - 12:05:10
echo date('d.m.Y - H:m:s', 329183999); // 07.06.1980 - 01:06:59
echo date('d.m.Y - H:m:s', 320); // 01.01.1970 - 01:01:20
- Tato funkce microtime() vrátí současný čas v mikrosekundách.
- Možná se ptáte, k čemu to je dobré. Je to dobré pro zjišťování doby chodu nějakého skriptu, načítání stránky nebo pro testování.
- Funkce má pouze jeden parametr a to typ bool, který je původně false. Pokud ho nastavíme na true, tak vrátí float hodnotu místo stringu.
Doporučuji vždy nastavovat true, pro návrat float hodnoty.
$zacatek = microtime(true); // zjisti aktualni cas for ($i = 0; $i < 99999; $i++); // vykona se nejaky skript $konec = microtime(true); // opet zjisti aktualni cas // vypise treba 0.017638921737671 sec echo $konec - $zacatek." sec"; // odectou se casy a vyjde delka zpracovani skriptu- Samozřejmě by to ještě chtělo zaokrouhlit, ale to už umíte.
- Funkce sleep() stejně jako funkce usleep() slouží k tomu, aby "uspali" současný chod skriptu na určitou dobu.
- Jediný rozdíl mezi těmito funkcemi je ten, že funkce sleep() má parametr pro sekundy a usleep() pro mikrosekundy.
echo date("s"); // vypise treba 10
sleep(5); // pocka 5s
echo date("s"); // vypise 15
- U funkce usleep() je to naprosto stejné, jen místo vteřin dáme mikrosekundy.
echo date("s"); // vypise treba 22
usleep(2e6); // pocka 2s
echo date("s"); // vypise 24
- Tato funkce list() je trochu zajímavá, protože vytváří proměnný, jako názvy prvků v poli.
- Nemá žádný přímý parametry, ale seznam parametrů (proměnných), ke kterým se má přidělit hodnota.
Pozor: List bych používal pouze tehdy, pokuď znám přesnou velikost (struktůru) pole.
// prvni pole
$pole = array("bagr", "kaktus", "necky"); // nejake pole o 3 prvcich
list($a, $b, $c) = $pole; // vytvorim si promenne s nazvem prvku v poli
echo $a." ".$b." ".$c; // vypisu "bagr kaktus necky"
// druhe pole
$pole2 = array(12, 24, 36);
list($a, $b, $c) = $pole2;
echo $a." ".$b." ".$c; // vypisu "12 24 36"
- Může se však stát, že budeme chtít vynechat prvek "kaktus" poli, protože ho nepotřebujem.
$pole = array("bagr", "kaktus", "necky");
list($a,, $b) = $pole; // preskocime prvek "kaktus"
echo $a." ".$b; // vypisu "bagr necky"
- Jak jistě už víme, tak pole nemusí být vždy stejný rozměr, co třeba dvou-rozměrné pole?
// pole s tremi prvkami a dalsim polem se dvema
$pole = array("bagr", "kaktus", "necky", array("mango", "kokos"));
list($a, $b, $c, $d) = $pole; // jako predtim si vytvorime promenne
echo $a." ".$b." ".$c; // vypisem prvni 3 prvky
echo $d; // toto nam vypise array, takže je nutné zadat index toho prvku ve vnitrnim poli
echo $d[0]." ".$d[1]; // vypise: "mango kokos"
- Někdy však tento případ není moc vhodný, abychom přistupovali k prvkům dalšího pole přes index.
$pole = array("bagr", "kaktus", "necky", array("mango", "kokos"));
list($a, $b, $c, list($d, $e)) = $pole; // jako predtim si vytvorime promenne
echo $a." ".$b." ".$c; // vypisem prvni 3 prvky
echo $d." ".$e; // vypisem 2 prvky z druheho pole
- Není problém přiřadit proměnným přímo nový index (třeba s názvem), tím můžeme používat stále jednu proměnnou.
// hlavni pole, na kterem budeme zkouset ruzne veci
$p = array("bagr", "kaktus", "necky", array("mango", "kokos"), 100);
// nazev promenne je stejny ale index ma stejny nazev jak prvek v poli
list($x[$p[0]], $x[$p[1]], $x[$p[2]], list($x[$p[3][0]], $x[$p[3][1]]), $x[$p[4]]) = $p;
echo $x["bagr"]." ".$x["kaktus"]." ".$x["necky"]; // vypisem prvni 3 prvky
echo $x["mango"]." ".$x["kokos"]; // vypisem 2 prvky z druheho pole
echo $x[100]; // vypisem posledni prvek
// stejny priklad jako nahore, jen dame promennym vlastni nazev indexu
list($x["bag"], $x["kak"], $x["nec"], list($x["man"], $x["kok"]), $x["num"]) = $p;
echo $x["bag"]." ".$x["kak"]." ".$x["nec"]; // vypisem prvni 3 prvky
echo $x["man"]." ".$x["kok"]; // vypisem 2 prvky z druheho pole
echo $x["num"]; // vypisem posledni prvek
// z kazdeho pole si vezmeme posledni prvek
list(,,, list(, $kok), $num) = $p;
echo $num." ".$kok; // vypisem: "100 kokos"
- Jak už jsem řekl, tak list pracuje s polem, takže můžeme použít třeba funkce explode(), kterou už z této lekce známe.
// nejaky predem naformatovany text
$text = "soubor.txt - log.txt - index.php - 404.php";
// rozdelime text podle " - " a kazdy prvek vlozime do nove promenne
list($soubor, $log, $index, $error) = explode(" - ", $text);
echo $soubor; // soubor.txt
echo $log; // log.txt
echo $index; // index.php
echo $error; // 404.php
- Představím vám pár konstant, které vám mohou usnadnit práci.
- Tyto konstanty jsou součástí jazyka PHP, takže si takové ani nemůžete vytvořit.
// vypise cestu s tomuto souboru a jeho nazev
echo __FILE__; // napriklad: C:/www/index.php
// vypise nazev funkce (stejne jako __CLASS__ pro tridu)
function bagr() { echo __FUNCTION__; }
bagr(); // vypise "bagr"
// uplne stejny priklad s funkci bude tento
function bagr() { echo __METHOD__; } // funkcim se jinak rika metody
bagr(); // vypise "bagr"
// vypise soucasny radek, na kterem se nachazi tento vypis
echo __LINE__; // vypise treba 680
echo PHP_INT_MAX; // vypise maximalni hodnotu int
echo PHP_INT_SIZE; // vypise velikost hodnoty int (4 byte)
echo PHP_VERSION; // vypise verzi PHP
echo DIRECTORY_SEPARATOR; // vypise oddelovat adresaru "\"
- Funkce dirname() vrací nadřazený adresář.
- Má pouze jeden parametr a to právě pro cestu s souboru a vrátí název adresáře, ve kterém se nachází ten soubor.
echo dirname(__FILE__); // vrati nazev adresare, ve kterem se nachazi tento soubor
echo dirname("C:/windows/explorer.exe"); // vrati "C:/windows"
echo dirname("/etc/passwd"); // vrati "/etc"
echo dirname("C:\windows\explorer.exe").DIRECTORY_SEPARATOR; // vrati "C:\windows\"
- Tato funkce basename() vrací název souboru bez přípony.
- Má 2 parametry, kde první je cesta k souboru a druhý suffix (přípona), která se má odebrat.
echo basename("C:/Windows/explorer.exe"); // vrati: "explorer.exe"
echo basename("C:/Windows/explorer.exe", ".exe"); // vrati: "explorer"
echo basename("/etc/passwd"); // vrati: "passwd"
- Tanto funkce phpinfo() vrací informace o PHP, na kterém tento skript běží.
- Nemusí mít žádný parametr (vypíše tak vše) nebo má jeden parametr a to typ informace, kterou chceme zobrazit.
- Typy informací máme několik.
- INFO_GENERAL : (1) - konfigurační linka, lokace php.ini, datum sestavení, web server, systém a další
- INFO_CREDITS : (2) - autoři jednotlivých modulů a vůbec tvůrci celého PHP
- INFO_CONFIGURATION : (4) - nastavení současné lokace a hlavní hodnoty PHP směrnic
- INFO_MODULES : (8) - nastavení o načtených modulech
- INFO_ENVIRONMENT : (16) - informace o proměnném prostředí
- INFO_VARIABLES : (32) - zobrazí všechny předdefinované proměnné z EGPCS (Environment, GET, POST, Cookie, Server)
- INFO_LICENSE : (64) - informace o licenci PHP
- INFO_ALL : (-1) - zobrazí vše
phpinfo(); // to same jako INFO_ALL phpinfo(INFO_CONFIGURATION); phpinfo(INFO_CREDITS | INFO_LICENSE); // vypise autory a licenci
- Opět k příkazům žádný nebude. Jen si opakujte a zkoušejte.