PHP tahák
Stránka není úplně dokončena, postupně bych rád přidával další postupy.
Základy syntaxe PHP - Poznámky - Echo - Proměnné - Operátory - Větvení - Vložení souboru include - Soubory a adresáře - MySQL - Datum a čas - Cookie
Základy syntaxe PHP
PHP se od html kódu oddělují sekvencemi <?php a ?>:
<?php php kód ?> html kód
Dříve se kódy začínaly sekvencí <? bez php. Ještě dnes to občas uvádím v příkladech, ale vždy je lepší používat <?php
V PHP nezáleží na řádkových zlomech (to jako entry). V PHP nezáleží na velikosti písmen, ale na velikosti písmen záleží v názvech proměnných.
PHP příkazy se oddělují středníkem:
<?php
příkaz;
příkaz; příkaz;
?>
Úseky programu se mohou uzavírat do složených závorek, zejména pro účely funkcí a větvení:
<?php
{příkaz; příkaz;}
?>
Příkazy se ukončují středníkem.
Poznámky
Aneb komentáře. Poznámky se neinterpretují a nezobrazují, jsou v kódu jenom kvůli lepšímu psaní.
Poznáky se oddělují se sekvencemi /* a */, nebo // až do konce řádku. Mříž # taky funguje jako //.
<?php
tohle není // a tohle je PHP poznámka // a tohle taky (prostě do konce řádku)
tohle není /* a tohle je PHP poznámka */ a tohle zase ne
/* tohle je PHP poznánka
tohle ještě taky */ a tohle ne
<!-- tohle není PHP poznámka -->
# a tohle je poznámka
?>
Echo
Co je v uvozovkách, jsou řetězce, ostatní jsou výrazy
<?php
echo "ahoj";
?>
vypíše Ahoj.
<?php
$promenna = "Karle";
echo "Ahoj ". $promenna;
?>
vypíše Ahoj Karle. Tečka spojuje řetězce.
Proměnné
Co začíná dolarem, je proměnná:
$promenna, $a
jsou proměnné.
V názvech proměnných záleží na velikosti písmen, takže např. $promenna je něco jiného než $Promenna. Je dobrým zvykem:
- jména proměnných psát jenom s malými písmeny
- jména konstant psát jenom velkými písmeny
Zpracování parametrů z URL
Pokud jsou v URL parametry (to je to za otazníkem), umí je PHP přebrat do proměnných asociativního pole $_GET. Takové URL s otazníkem se zpravidla vytvoří odesláním furmuláře. Např. URL:
index.php?a=1&b=2
předá PHP proměnné $_GET['a'] a $_GET['b'] s hodnotami 1 a 2. Takže třeba
<?php
echo $_GET['a'] + $_GET['b'];
?>
vypíše 3.
Pokud má někdo na serveru nastavenu instrukci
register_globals = on;
tak by v předchozím příkladu mohl pracovat rovnou s proměnnými $a a $b. Ale register_globals = on je právem považováno za nebezpečné nastavení, takže je na většině serverů vypnuto. Proto je potřeba naučit se pracovat s polem $_GET.
Zjištění, jestli je proměnná definovaná
Na to je funkce isset($proměnná). Jestliže je proměnná definovaná a má hodnotu, pak isset() vrací true.
if (isset($promenna)) ...
Operátory
Výčet není vyčerpávající
| . | spojování řetězců |
| + | sčítání |
| - | odčítání |
| * | násobení |
| / | dělení čísel (racionálních i celých) |
| % | zbytek po dělení (modulo) |
| ++ | přičtení jedničky |
| -- | odečtení jedničky |
Operátory přiřazení
| = | přiřazení |
| .= | připojení řetězce k téže proměnné |
| += | přičtení čísla k téže proměnné |
| -= *= /= %= |
odpovídající operace na téže proměnné |
Logické operátory
| && | a zároveň |
| || | nebo |
| podmínka?ano:ne | pokud platí podmínka, je výsledek ano, jinak ne |
Porovnávací operátory
| == | rovnost |
| != <> |
nerovnost |
| < | je menší |
| <= | je menší nebo rovno |
| >= | větší nebo rovno (pomůcka: je to v pořadí, jak se to čte) |
Větvení
If - jestliže
if(podmínka) příkaz;
nebo s chlupatými závorkami:
if(podmínka)
{příkaz;příkaz;}
nebo s else
if($a == $b)
{příkazy;}
else
{příkazy;}
Případně s elseif:
if(podmínka)
{příkazy;}
elseif(jiná_podmínka)
{příkazy;}
else
{příkazy;}
Podmíněný výpis HTML kódu:
<?php
if(podmínka) {
?>
//
výpis html kódu (klidně i složitý)
<?php
} // uzavření podmínky
?>
Nebo úplně jiný zápis if s dvojtečkou (já ho mám radši):
if(podmínka):
příkaz;
příkaz;
endif;
Případně totéž s else:
if (podmínka):
příkaz;
příkaz;
else:
příkaz;
příkaz;
endif;
Podmíněné vypisování html kódu s dvojtečkovou syntaxí:
<?php
if($vypsat == 1):
?>
<b>Tento kód se vypíše, pokud proměnná <var>$vypsat</var> bude 1.</b>
<?php
endif;
?>
Switch
Testuje se hodnota proměnné $a a podle toho, jakých nabývá hodnot (vypsaných za case), se provádí příkazy
switch ($a)
{
case "hodnota1":
příkazy;
break;
case "hodnota2":
case "hodnota3":
příkazy;
break;
default:
příkazy;
}
For
Nejdříve se nastaví proměnná $a, poté následuje podmínka, za které se bude cyklus for provádět a nakonec se zvětšuje nebo zmenšuje hodnota proměnné $a (v tomto příkladu se zvětšuje o jedničku, to je to a++).
for($a=1;$a<5;$a++){
echo $a;
}
Vypíše se 1234.
Cyklus se bude provádět tak dlouho, dokud je podmínka platná (podmínka je druhý příkaz v závorce za for). Jakmile podmínka platná nebude, cyklus neproběhne a jde se dál. Dá se to symbolicky popsat i takhle:
for($a=1 /* co se provede před prvním průchodem */; $a<5 /*co musí platit před každým průchodem, jinak konec */;$a++ /* co se provede po každém průchodu */)
Vložení souboru - include
include "./ahoj.php";
vloží do právě zpracovávané strány soubor ahoj.php.
Include vkládá soubory jako normální text. Pokud to bude html stránka, prostě ji vypíše do výsledku. Pokud v souboru ahoj.php budou php instrukce, musejí být klasicky ohraničené sekvencemi <?php a ?>.
Ta tečka lomítko na začátku znamená, že se soubor bude hledat v aktuálním adresáři (tedy v tom, ve kterém je zpracovávaný skript). Jinak by se soubory hledaly v adresáři, který má PHP nastaveno jako include_path. Includování souborů z aktuálního adresáře totiž nemusí být u ostrých aplikací bezpečné (dá se k nim dostat z webu).
Soubory a adresáře
Čtení adresářů
Podívá se do aktuálního adresáře, vypíše ho a jeho obsah si navíc nasype do pole $files[] (bez virtuálních souborů .. a .).
<?php
$adresar=opendir("./");
while ($jmenosouboru = readdir($adresar)) {
echo "$jmenosouboru <br>"; // vypsani, pro kontrolu
if ($jmenosouboru != "." && $jmenosouboru != "..") {
$files[] = $jmenosouboru;
} */
}
closedir($adresar);
?>
Čtení souborů
<?php
$soubor = fopen ("./text.txt", "r");
$prvni=fgets($soubor); //prvni radek, protoze fgets volam poprve
$druhy=fgets($soubor, 255); // druhy radek, protoze fgets volam podruhe, omezeny
na 255 znaku
fclose($soubor);
echo "První řádek: $prvni <br>";
echo "Druhý řádek: $druhy";
?>
Zápis do souborů
<?php
$soubor = fopen("./text.txt", "w"); // "w", jako že budu zapisovat
fwrite($soubor, "Obsah souboru\n"); // to \n znamena novy radek a byt tam musi,
jinak se to neodradkuje.
fwrite($soubor, "druhý řádek");
fclose($soubor);
?>
Nebude to fungovat, pokud adresář, ve kterém je soubor uložen, nebude mít nastavena práva pro zápis. Někdy má, někdy nemá, záleží na hostingu. Práva pro adresář se dají nastavit i přes FTP (třeba v Total Commanderu).
Tytéž příklady jsem komentoval v samostatném článku o souborech v PHP.
Mysql
Každé operaci předchází:
- vytvoření spojení na mysql server
- výběr databáze
Teprve potom následuje vlastní SQL dotaz.
Připojování na mysql databázi
// připojím se na databázi
$spojeni =
MySQL_Connect("localhost", "dusan", "sew57");
// vyberu databázi
MySQL_Select_DB("knihovnicka", $spojeni);
a potom se můžu vrhnout do operací nad tabulkami (jako jsou selecty nebo inserty). V další práci budu používat identifikátor spojení v proměnné $spojeni. MySQL_Connect() má 3 parametry -- adresu databázového serveru, jméno uživatele a jeho heslo. MySQL_Select_DB() má parametr jméno databáze (často shodný se jménem aplikace).
Vytvoření mysql tabulky
Vytvořím tabulku "knihy" se třemi sloupci: id, název, autor:
$spojeni = MySQL_Connect("localhost", "dusan", "sew57");
MySQL_Select_DB("knihovnicka", $spojeni); //to je popsáno výše
MySQL_Query("CREATE TABLE 'knihy' (
'id' INT NOT NULL AUTO_INCREMENT,
'kniha' VARCHAR(64),
'autor' VARCHAR(64 )
)", $spojeni);
Vložení záznamů do mysql databáze
$spojeni = MySQL_Connect("localhost", "dusan", "sew57");
MySQL_Select_DB("knihovnicka", $spojeni); //to je pořád to samé připojování
MySQL_Query("INSERT INTO knizky VALUES (0,'Harry Potter','Rowlingová');",
$spojeni);
Nebo ten dotaz může být zapsaný jinak (když si nejsem jistý pořadím sloupců, nebo když nechci hodnotami naplnit všechny sloupce):
MySQL_Query("INSERT INTO knihy (id, kniha, autor) VALUES (0, 'Harry Potter', 'Rowlingová');", $spojeni);
Vizte též vytvoření databáze a tabulky v MySQL přes SSH (v konzoli na serveru).
Nejčastější chybou v začátku jsou špatně napsané uvozovky, závorky, čárky a středníky. Řetězcová hodnota se vždycky ukládá do databáze v uvozovkách (jednoduchých nebo dvojných, záleží na zápisu). Proto je vždy potřeba obklopit uvozovkami i jména PHP $proměnných, pokud je v nich řetězcová hodnota:
MySQL_Query("INSERT INTO knizky VALUES (0,'$nazev','$autor');", $spojeni);
Tipy pro práci s MySQL
V případě, že se vyskytnou problémy, lze si nechat poslední chybu, kterou zaznamenala MySQL databáze, pomocí příkazu:
echo mysql_error($spojeni);
Během vývoje je dobré používat nějaký nástroj na správu databáze, aby bylo jasné, co se vlastně s daty děje. Například doporučuju PHPMyAdmin nebo Adminer.
Datum a čas
čas vhodný pro ukládání do MySQL:
$cas = Date("Y-m-d H:i:s");
nebo jenom datum:
$datum = Date("Y-m-d");
Pokud se neuvede druhý parametr, tak se bere aktuální čas. Druhý parametr umožňuje zadat jiný čas (takže se zformátuje).
$datum = Date("Y-m-d", $jinycas);
Cookie
Uložení cookie v PHP:
SetCookie("user", "pavel", Time() + 7*24*60*60);
cookie se jmenuje "user" a uloží se do ní hodnota "pavel". Platí 7 dnů od teďka (je to v sekundách) a platí pro celou doménu (narozdíl od javascriptu, kde platí jenom pro aktuální url). Kdyby měla platit jinak, tak se to nastavuje čtvrtým (cesta) a pátým (doména) parametrem.
Čtení cookie:
Hodnota cookie se pro potřeby PHP skriptu může automaticky načítat do proměnné stejného jména, tedy například do $user z předchozího příkladu, to ale záleží na nastavení PHP.
Spíše dopouručji využívat, že je v asociativním poli $_COOKIE, tedy například.
echo $_COOKIE["user"]; // vypíše hodnotu cookie jménem user, pokud je nastavena
Reklama
