- Takže... prvním příkazem, co je celkem užitečný a může se hodit je příkaz unset(var).
- Tento příkaz je vlastné takový destrukční. Odnastaví a zničí proměnnou.
$cislo = 100; unset($cislo); // znici promennou $cislo echo $cislo; // vypise upozorneni, ze promenna $cislo neexistuje- Lze také funkci unset() nastavit jako typ, ten se poté bude lišit v tom, že proměnná bude existovat, ale nevypíše nic.
$cislo = 100; $prom = (unset) $cislo; // promenna $prom bude vlastne null echo $prom; // nevypise nic echo (unset) $cislo; // tez nevypise nic echo $cislo; // vypise 100- Funkce unset() má neomezený počet parametrů. To znamená, že zničit může hned nekolik proměnných najednou a nemusíme ničit každou zvlášť.
$a = 10; $b = 20; $c = 30; unset($a, $b, $c); // znicime vsechny 3 promenne- Tato funkce se může hodit zejména kvůli zabezpečení. Pokud třeba proměnná bude obsahovat nějaký citlivý údaj, tak po použití jí můžeme hned odebrat.
- Funkce define() je vlastně definice vlastní konstanty.
- Skládá se ze 3 parametrů, kde první určuje název konstanty, druhý její hodnotu a třetí ovlivňuje velikost písmen.
- Každý název konstany musí mít jedinečné jméno!
define('MOJE', "Ahoj světe"); // definice vlastni konstanty a jeji hodnoty
define('CISLO', 1337); // opet definice hodnoty
echo MOJE; // vypisu "Ahoj světe"
echo CISLO; // vypisu 1337
- Konstanta je typu public, to znamená, že jí můžete používat všude bez vyjjímky.
define('BAGR', "jůů", true); // to same jako predtim, jen se nerozlisuje velikost pismen
echo BAGR; // vypisu "jůů"
echo bagr; // vypisu tez "jůů"
- Samozřejmě bez třetího parametru můžeme dát též definici konstanty na malé písmeno. Rozdíl je jen ten, že to bude rozlišovat velikost písmen konstanty.
define('VERZE', "1.0.0"); // deklarace konstanty pro verzi
define('HLAVNI_CISLO', 150); // deklarace hlavniho cisla
$cislo = 100;
$celkem = HLAVNI_CISLO + $cislo; // 150 + 100
echo $celkem." ve verzi ".VERZE; // vypise: 250 ve verzi 1.0.0
- Jak vidíte, je to stejné jak proměnné, jen s tím rozdílem, že konstanty se píší velkýmí písmeny, zapisují se bez dolaru $,
pokud název obsahuje více slov, tak se oddělují podtržítkem _, jejich hodnoty se nedají měnit a lze je použít všude.
- Funkce defined() je typu bool. To znamená, že vrací true nebo false.
- Používá se především pro zjištění, jestli definice konstanty již existuje nebo ne.
define('VERZE', "1.0.0"); // deklarace konstanty VERZE
if (defined('VERZE')) // vrati true, protoze VERZE existuje
{
echo VERZE; // vypise verzi: 1.0.0
}
else echo "Konstanta VERZE neexistuje!";
- K tomu není co dodat. Jednoduše zjišťuje existenci konstanty.
if (!defined('BAGR')) // vrati true, protoze BAGR neexistuje
{
define('BAGR', "bagřík"); // definice konstanty BAGR
}
echo BAGR; // vypise "bagřík"
- Když už jsme u těch konstant, tak trochu novější a podlě mě i přehlednější je to přes příkaz const.
- Příkaz const pro definici konstanty se používá špíše v uzavřeném prostoru - funkce, třídy, rozhraní apod.
const NUM = 100; // definuje konstantu NECO s hodnotou 100 echo NUM; // vypise hodnotu 100- Na tento příkaz jde též aplikovat funkce defined(), aby jsme zjistili, zda konstanta existuje.
const NUM = 100; // definuje konstantu NECO s hodnotou 100
if (defined('NUM')) echo NUM; // pokud konstanta existuje, tak ji vypise
- Je vlastně ještě jeden způsob, jak přistupovat ke konstantě, ale osobně ho nepoužívám, přijde mi zbytěčně složitý a ve výsledku se nic nemění.
const NUM = 100; // definuje konstantu NECO s hodnotou 100
const neco = "text"; // opet definice
echo NUM; // bezny vypis konstanty
echo constant('NUM'); // to same
echo constant('neco'); // hned je videt, ze "neco" je konstanta, i kdyz ma male pismena
- Tyto 2 příkazy die a exit jsou naprosto totožné. Takže je pouze na vás, který budete používat.
- Příkazy lze použít s parametrem výstupu (třeba nějaký text co se má vypsat) i bez parametru.
- Udělají vlastně to, že ukončí současný script.
// tyto formaty maji stejny vyznam
exit;
exit();
exit(0);
// urcime kod chyby
exit(1);
exit("Nastala chyba!");
- To samé jde samozřejmě provést i u příkazu die, ale tam se více používá nějaký text, pro oznámení chyby. Něco jako u exit na řádku 8.
$num = 51;
if ($num != 50) die("Stránka byla ukončena, protože hodnota $num neodpovídá!");
- Tyto 2 funkce spadají do hashovacích algoritmů.
- Obě tyto funkce nejdou dekódovat - pouze se porovnávají (i když existují i crackery - hlavně na md5()).
- Napřed si ukážeme funkci md5(), která má 2 parametry.
$tajne = "mimic"; echo md5($tajne); // vypise: 512722c4e72b55fc76e260c26182ff7c echo md5($tajne, true); // vypise binarni podobu: Q'"��+U�v�`�a��|- Funkce sha1() je na tom podobně.
$tajne = "mimic"; echo sha1($tajne); // vypise: 76c54c7e68822e3cc743c8b29445c7890aa8d73d echo sha1($tajne, true); // vypise binarni podobu: v�L~h�.<�CȲ�Elj ��=- Lze tyto 2 algoritmy spojovat nebo jeden typ aplikovat několikrát dle libosti.
$tajne = "mimic"; echo ms5(md5($tajne)); // vypise: b5267052f66d3bd8b4b79f87d6e879b4 echo md5(sha1($tajne)); // vypise: c88f5b5c2fff18d16af3e1d74ddf9fbe- Jak už jsem řekl, tak je nutno porovnávat hodnoty, zda uživatel zadat správné heslo.
$heslo = md5("mimic");
$vstupniHodnota = "neco";
if (md5($vstupniHodnota) == $heslo) // porovname 2 hashe
{
echo "heslo je správné";
}
else echo "heslo je špatně!";
- Když už jsme u těch hashovacích algoritmů, tak tato funkce hash() disponuje hned několika druhy algoritmů.
- Lze tedy přes tuto funkci použít třeba nejvyšší úroveň algoritmu sha1 jako sha512.
- Tato funkce má 3 parametry, kde první je typ algoritmu, druhý je text, co chcete zahashovat a třetí na binární výstup.
$heslo = "mimic"; // tajne heslo
/* vypise:
* 626fb344b08a941f0ac93e55d69afbad56577c53155
* 2e59045f094f2b8d9d9844864fdb1172571e8d5683a
* 9e16cfc89609828af1b587c9bdff85e2ffa0637da1
*/
echo hash('sha512', $heslo); // nejsilnejsi hashovaci algoritmus
/* vypise:
* 9cb787c89636c16ef7b641183812485bd51aed21de9
* ce5a8ed7ea8568e986974d0a8da939f0390b8df4d55
* c024ab9ce3627dd522eb99bde12bd7043377d657d1
*/
echo hash('whirlpool', $heslo); // podle meho nazoru druhy nejsilnejsi
echo hash('md2', $heslo); // vypise: 40d5656d88a3e9e208230a96c311b436
echo hash('md4', $heslo); // vypise: b0c3f0efca57c740d765ed825423e7cc
echo hash('md5', $heslo); // vypise: 512722c4e72b55fc76e260c26182ff7c
echo hash('crc32', $heslo); // vypise: aa823e56
echo hash('adler32', $heslo); // vypise: 06460210
// vypise: dbeb8c0a0bc371cc3168b490c16d747818e425f6df4a703f
echo hash('tiger192,4', $heslo);
// vypise: 4d78d8317e15bba6cb5b357c78e009607c6ff383381d55ff8e3074fc1191ff38
echo hash('haval256,4', $heslo);
// vypise: bd6d1e386ae832f51f32451193226d1985d7b2149500d63920fe356ce2121ba6a79fa2cb588434ab
echo hash('ripemd320', $heslo);
// vypise: 224378964eb70343c15289500dc34aca2911c24e90be1529d06a0c1f562322da
echo hash('gost', $heslo);
// vypise: 8bff9cf1087e27592bec553b088df833f327a01d48a8caae33d2d9a846c49de9
echo hash('snefru', $heslo);
- Jak vidíte, tak algoritmů je mnoho a to nejsou zdaleka všechny. Vypsal jsem pouze některé.
$heslo = "mimic";
// vypise: bo�D��� �>U֚�VW|SR�E���لHd�%q��h:��Ȗ ���ɽ�����c}�
echo hash('sha512', $heslo, true); // prevede hash do RAW - binarni podoba
- Tato funkce bin2hex(), jak již název napovídá, převádí binární text do hexadecimálního výstupu.
- Má jeden parametr pouze pro vstupní text, takže není moc co řešit.
- Lze jí uplatnit třeba u hash algoritmu, kde převádíme do RAW výstupu a chceme ho opět převést do hex.
$heslo = "mimic"; $bin = md5($heslo, true); // v bin bude RAW: Q'"��+U�v�`�a��| $hex = bin2hex($bin); // zde bude hex: 512722c4e72b55fc76e260c26182ff7c echo md5($heslo); // vypise: 512722c4e72b55fc76e260c26182ff7c echo $hex; // vypise tez: 512722c4e72b55fc76e260c26182ff7c- Pokud ovšem zadáme normální text, tak nám to vrátí hexa výstup - převede jednotlivé znaky do hex.
echo bin2hex("mimic"); // vypise: 6d696d6963
- tyto funkce slouží též k převodu a převádí binární číslo do decimálního a obráceně.
- Napřed si tedy ukážem funkci bindec(), která jako funkce decbin() má jeden parametr.
- Vstup lze zapsat jako číslo nebo string, ale pokud bude string, tak musí obsahovat pouze čísla. Čte znaky z leva do prava a pokud narazí na znak,
který není číslo, tak se zastaví a provede vše do toho znaku.
- U funkce bindec() je doporučeno používat vstup jako string.
echo bindec("11"); // 3
echo bindec("1100"); // 12
echo bindec("110011"); // 51
echo bindec("11001100"); // 204
echo bindec("1100110011"); // 819
echo bindec("110011001100"); // 3276
echo bindec("10101010101010101010101010101010101010101010101"); // 93824992236885
echo bindec(110011); // 51 (neni chyba, ale tento tvar se moc nepouziva)
- Druhá funkce decbin() je opakem bindec().
// vsechny tyto formaty lze pouzit i u funkce bindec()
echo decbin(3); // 11 (doporuceny tvar)
echo decbin("3"); // 11 (lze taky pouzit)
echo decbin("3.5"); // 11 (bere vsechna cisla do znaku .)
echo decbin("3R1"); // 11 (bere vsechna cisla do znaku R)
echo decbin(3.5); // 11 (to same jako predtim)
echo decbin(12); // 1100
echo decbin(51); // 110011
echo decbin(204); // 11001100
echo decbin(819); // 1100110011
echo decbin(3276); // 110011001100
echo decbin(93824992236885); // 10101010101010101010101010101010101010101010101
- Tyto 3 funkce se používají na zaokrouhlování čísla.
- Jako první si ukážem funkci round(), lterá je nejznámější.
- Tato funkce má 3 parametry. První určuje vstup čísla, druhý posun desetinné čárky a zaokrouhlení a třetí určuje mód - více potom v ukázce.
echo round(10.123); // zaokrouhli smerem dolu = 10 echo round(10.499); // zaokrouhli tez smerem dolu = 10 echo round(10.500); // zaokrouhli smerem nahoru = 11 echo round(55); // vypise 55- Druhý parametr udává pohyb desetinné čárky. O kolik míst se má posunout a kam.
// pohyb carky doprava echo round(10.123, 2); // 10.12 echo round(10.499, 2); // 10.5 echo round(10.500, 2); // 10.5 echo round(10.485697, 3); // 10.486 echo round(55, 2); // 55 // pohyb carky doleva echo round(55, -2); // 100 echo round(123, -2); // 100 echo round(1230, -2); // 1200 echo round(156987, -4); // 160000- Pokud chceme pohybovat čárkou doleva a zaokrouhlit, tak to jde pouze u celých čísel!
echo round(10.5, 0, PHP_ROUND_HALF_UP); // 11 echo round(10.5, 0, PHP_ROUND_HALF_DOWN); // 10 echo round(10.5, 0, PHP_ROUND_HALF_EVEN); // 10 echo round(10.5, 0, PHP_ROUND_HALF_ODD); // 11 echo round(3.5, 0, PHP_ROUND_HALF_UP); // 4 echo round(3.5, 0, PHP_ROUND_HALF_DOWN); // 3 echo round(3.5, 0, PHP_ROUND_HALF_EVEN); // 4 echo round(3.5, 0, PHP_ROUND_HALF_ODD); // 3- Další příkaz bude příkaz floor().
echo floor(10.99); // 10 echo floor(10.5); // 10 echo floor(10.11); // 10 echo floor(-2.55); // -3- Poslední příkaz je příkaz ceil(), který je stejný jak příkaz floor(), jen s rozdílem, že zaokrouhluje směrem nahoru.
echo ceil(10.99); // 11 echo ceil(10.5); // 11 echo ceil(10.11); // 11 echo ceil(-2.55); // -2
- Tato funkce number_format(), slouží pro formátování číselného tvaru.
- Má 4 parametry, takže je vezmem postupně.
- První parametr určuje vstup čísla.
echo number_format(10.568); // 11 echo number_format(10.1); // 10- Jak vidíte, tak funguje stejně jako příkaz round() pro zaokrouhlení.
echo number_format(10.568, 2); // 10.57 echo number_format(10.1, 2); // 10.10 echo number_format(1337, -2); // 1,337 (vsimnete si carky misto tecky) echo number_format(31337, -2); // 31,337 (vsimnete si carky misto tecky) echo number_format(50, 2); // 50.00- Tak přejdeme na třetí a čtvrtý parametr. Tyto 2 poslední parametry jsou nutné oba. To znamená, že pokud zadáme 3. parametr, musíme zadat i 4.
// upravi pouze na 50.12, pote misto tecky zapise dvojtecku echo number_format(50.123, 2, ":", "."); // 50:12 // upravi a zaokrouhli na 1234.57, pote za kazde 3. cislo da carku a za desetinne tecku echo number_format(1234567890.123, 2, '.', ','); // 1,234,567,890.12 // to same jako predtim, jen odebere vse za desetinnou carkou a zmeni carku za mezery echo number_format(1234567890.123, 0, null, ' '); // 1 234 567 890- Něco je možná težší pochopit, ale jinak na tom nic moc není. Hlavně to usnadní práci s formátováním.
- Nejprve začnu funkcí print().
- Je to vlastně starší obdoba příkazu echo.
- Je dobré o této funkci vědět, ale nedoporučuji ji používat jako náhradu za echo.
print "nějaký text";
print("nějaký text 2");
- Jak říkám, stejné jak echo.
/* vypise:
* TEXT1.............200
* TEXT2.............500
*/
printf("%'.-15s%'.6s
", "TEXT1", 200); // budem rozebirat pod ukazkou
printf("%'.-15s%'.6s
", "TEXT2", 500);
- Trochu si to rozeberem. Máme tu 2 argumenty, kde jeden je TEXT1 a druhý 200.
printf("%s%d", "TEXT", 200); // TEXT200
printf("%s", "TEXT", 200); // TEXT
printf("%s = %d", "TEXT", 200); // TEXT = 200
// vytvori nam za TEXT 5x tecku a -10 je tam proto,
// protoze to jde od 0 znaku a slovo TEXTX ma 5 znaku
// a ten apostrof za procentem je tam povinny
printf("%'.-10s", "TEXTX", 200); // TEXTX.....
printf("%'--10s> (%d)", "TEXTX ", 200); // TEXTX ----> (200)
printf("(%d + %d) / %d = %d", 10, 20, 30, 1); // (10 + 20) / 30 = 1
- Kombinací jak naformátovat text pomocí funkce printf() je mnoho, takže se tím tady moc zabejvat nebudu. Aspoň vidíte, jak to zhruba vypadá.
- V lekcích o příkazech nebudu dávat žádné úkoly, protože vysvětlení je celkem dost jasné, takže si stačí pouze opakovat.