PHP mini manuál

Super stručný přehled často používaných funkcí jazyka PHP. Tento přehled má sloužit jako rozcestníček pokud vůbec nevíte jak na to, nikoliv jako náhrada manuálu.

PHP skript by měl mít příponu .php. Na *nixových serverech (kterých je větší část) záleží na velikosti písmen takže opravdu .php. Podle konfigurace serveru mohou jako php soubory být interpretované i soubory s jinými příponami (na Apache serveru direktiva AddType případně ForceType). Vlastní skript by měl začínat značkou <?php, můžete se setkat i se zkrácenou značkou <? nebo <?= Používání zkrácené značky není vhodné a zkuste se mu vyhnout – je to jen lidská lenost (zkrácená značka v podstatě serveru říká, že následuje kód ve skriptovacím jazyce, ale neříká v jakém – z čehož mohou plynout různé problémy). Konec skriptu označuje značka ?>.

Kromě vlastního PHP skriptu může soubor obsahovat i text mimo značky PHP skriptu, tento text se bez jakéhokoliv zpracování přepošle prohlížeči. PHP skript tedy může být i celá statická stránka, do které se může do nějakého místa vypisovat dynamicky nějaká drobnost např:
…<div class='dnes'>Dnešní datum je: <?php echo date('d.m.Y'); ?> Přeji hezký den</div>…
Pro složitější stránky tento způsob nepoužívejte, je velice nepřehledný a náchylný k chybám. Stejně tak tento přístup (tedy kombinované statické HTML a PHP v jednom souboru) nepoužívejte pokud chcete pracovat se $_SESSION nebo s $_COOKIE - tedy pokud chcete uchovávat stav aplikace - například přihlášení a podobně. Důvodem je to, že pak není možné (bez output bufferu) odesílat HTTP hlavičky. Poznámka: koncová značka PHP se neuvádí, pokud za ní již není žádný text – tedy je na konci souboru. Což je u dobrého skriptu vždy (protože jinak může selhat posílání HTTP hlaviček).

Řádkové komentáře se v PHP označují pomocí: //. Víceřádkové komentáře začínají: /* a končí: */

Datové typy

PHP je jazyk s tzv. slabými datovými typy. Znamená to, že u proměnné nedeklarujeme jakého je typu, ale datový typ proměnné je určen jejím obsahem. Uložíme-li do proměnné například hodnotu $a = 4, stane se z ní proměnná typu integer. Změníme-li hodnotu na $a = 'úterý', stane se z ní proměnná typu string. Použijeme-li hodnotu v podmínce if ($a) , stane se z ní v tu chvíli hodnota typu boolean. To je na jednu stranu velmi praktické – typicky následující konstrukce (proměnná $handle obsahuje ukazatel na otevřený soubor):
$handle = fopen(…)
if ($handle) {
    fread($handle, …)
}
Na druhou stranu, to může vést k překvapivým výsledkům:
echo 1 + '2' + '3.úterý';
vypíše hodnotu 6. Při přetypování je zejména důležité přetypovávání na booleovské hodnoty. Pro toto platí následující poučka: Za booleovskou hodnotu false se považuje: false, 0, 0.0, '' (prázdný řetězec), '0' (řetězec nula!), array() (prázdné pole), null (bez hodnoty). Všechny ostatní hodnoty (až na pár nedůležitých výjimek) se považují za true.

Legenda

  • klíčové slovo
  • funkce()
  • parametr
  • $proměnná
  • [nepovinný parametr]

Jazykové konstrukce

Řetězce

  • začínají a končí uvozovkami ' (jednoduché) nebo " (dvojité)
  • řetězec uvnitř jednoduchých uvozovek nesmí uvnitř obsahovat jednoduché uvozovky, analogicky to platí pro řetězec ve dvojitých uvozovkách.
  • v řetězci v jednoduchých uvozovkách je možné používat modifikátor \' pro potlačení významu a vytištění jednoduchých uvozovek.
  • v řetězci v jednoduchých uvozovkách se zachovávají tabulátory a konce řádků tak, jak jsou uvedené ve zdrojovém kódu.
  • v řetězci ve dvojitých uvozovkách je možné používat modifikátor \" pro potlačení významu a vytištění dvojitých uvozovek.
  • v řetězci ve dvojitých uvozovkách se nezachovávají tabulátory a konce řádků, pro jejich vytištění je potřeba použít modifikátory \n (konec řádku – newline) a \t (tabulátor).
  • pro potlačení významu \ se používá \\
  • pro spojování řetězců se používá operátor . (tečka), spojovat je možné i řetězce s různými typy uvozovek.

Příklady:

  • echo 'ahoj' te'; => syntaktická chyba
  • echo 'ahoj\' te'; => ahoj' te
  • echo "ahoj' te"; => ahoj' te
  • echo "ahoj\' te"; => ahoj\' te
  • echo 'ahoj" te'; => ahoj" te
  • echo 'ahoj\" te'; => ahoj\" te
  • echo 'ahoj\\' te'; => ahoj\\' te
  • echo 'ahoj\n te'; => ahoj\n te
  • echo "ahoj\n te"; => ahoj
    te
  • echo "ahoj\t te"; => ahoj     te
  • echo "ahoj\\n te"; => ahoj\n te

Logický výraz (true nebo false)

  • Pro porovnání je možné používat operátory: == (hodnota je stejná) , >, >= , <, <= , != (není rovno – hodnota je různá) , === (hodnota i datový typ jsou stejné) , !== (hodnota nebo datový typ jsou různé)
  • Logické operátory jsou: && (a současně/and), || (nebo/or) , ! (negace/not)
  • Kromě toho existují i logické operátory and a or, které fungují stejně jako && a ||, ale mají jiné pořadí vyhodnocování.
  • Kromě toho existují i operátory & a |, které fungují jako bitový and a or (v normálních podmínkách se tedy nepoužívají).

Příklad: ($a > 0) && (($b == 42) || ($c != 0))

Modifikace proměnné

  • přiřazení:
    $i = 10;
  • přičtení (+)/odečtení (-):
    $i = $i + 10;
    $i += 10;
    $i++ (přičtení 1)
  • násobení (*)/dělení (/):
    $i = $i * 10;
    $i *= 10;
    (pro céčkaře: dělení vrací desetinné číslo)
  • spojení řetězců (operátor tečka):
    $i = $i . 'ahoj';
    $i .= 'nazdar'; (připojení řetězce k proměnné)
  • modulo (zbytek po celočíselném dělení):
    $i = $i = 5;
    $i %= 5;

Podmínka

  • Podmínka:
    if (logický výraz) {
        příkazy
    }
  • Podmínka s částí, která se vykoná pokud není podmínka splněna:
    if (logický výraz) {
        příkazy
    else {
        příkazy
    }
  • Cyklus se zadaným počtem iterací (průchodů):
    for ($indexovací_proměnná = počáteční_hodnotapodmínka_ukončení_cyklumodifikace_proměnné) {
        příkazy
    }
  • Cyklus pro zpracování asociativního pole 1:
    foreach ($pole as $proměnná_pro_hodnotu_prvku) {
        příkazy
    }

    Tento cyklus projde vždy celé pole ($pole) a v každém průchodu uloží do zadané proměnné ($proměnná_pro_hodnotu_prvku) hodnotu aktuálního prvku. Využívá se zejména pro asociativní pole, nebo pro pole, ve kterých neznáme indexy.
  • Cyklus pro zpracování pole 2:
    foreach ($pole as $proměnná_pro_hodnotu_klíče => $proměnná_pro_hodnotu_prvku) {
        příkazy
    }

    Využití cyklu je stejné jako u předchozího. Pouze umožňuje navíc zpracovávat i indexy (klíče) v poli.
  • Cyklus s podmínkou na začátku:
    while (podmínka_ukončení_cyklu) {
        příkazy
    }
  • Cyklus s podmínkou na konci:
    do {
        příkazy
    while (podmínka_opakování_cyklu);

Funkce pro práci s proměnnými

  • isset(proměnná)
    Zjistí zda je proměnná nastavena (byla použita). Příklady:
    • $ret = "abcdefg";
      isset($ret); //vrátí true
    • $ret = "";
      isset($ret); //vrátí true
    • $ret = 0;
      isset($ret); //vrátí true
    • <?php
      isset($ret); //vrátí false
    • $pole['test'] = "";
      isset($pole['test']); //vrátí true
    • $pole['test'] = "";
      isset($pole['pokus']); //vrátí false
  • empty(proměnná)
    Zjistí zda je proměnná nenastavena (nebyla použita), nebo má prázdnou hodnotu. Příklady:
    • $ret = "abcdefg";
      empty($ret); //vrátí false
    • $ret = "";
      empty($ret); //vrátí true
    • $ret = 0;
      empty($ret); //vrátí true
    • <?php
      empty($ret); //vrátí true, proměnná není nastavena
  • include(název souboru) nebo include název souboru
    Vloží do aktuálního souboru obsah jiného souboru. Pokud jiný soubor obsahuje spustitelný kód (tedy vždy pokud jsou v souboru nějaké příkazy mimo deklarace funkcí a tříd), pak se kód ihned provede. Jako název souboru je možné použít běžnou relativní nebo absolutní cestu. Příklady:
    • include('connect.php');
    • include('./../connect.php');
    • include('/data/wwwroot/connect.php'); //absolutní cesta na jiném, než windows serveru
    • include('c:/data/wwwroot/connect.php'); //absolutní cesta na windows serveru (server se smíří i s normálními lomítky)
    • Příklad vložení a provedení kódu:
    • obsah souboru incld.php:
      <?php
      $a = 15;
      ?>
    • obsah souboru main.php:
      <?php
      $a = 10;
      include('incld.php');
      echo $a; //vypíše 15
      ?>
  • include_once(název souboru) nebo include_once název souboru
    Totéž jako include(), ale zajistí, aby se vkládaný skript během celého spuštění skriptu vložil pouze jednou. Je užitečné pro složitější spojení skriptů. Není potřeba řešit chyby typu 'function already defined'.
  • require_once(název souboru) nebo require název souboru
    Totéž jako include(), liší se pouze v řízení chyb. Pokud požadovaný soubor není nalezen, tak require() zahlásí fatální chybu a ukončí celý skript, naproti tomu include() v tomto případě pouze vypíše varování a pokračuje dál ve spouštění skriptu. Podle očekávání existuje taky require_once(), což je ekvivalent include_once().
  • intval(hodnota)
    Převede hodnotu v parametru na celé číslo (integer) a vrátí výsledek. Název funkce intval znamená integer value. Příklady:
    • intval(4); //vrátí 4
    • intval(4.98); //vrátí 4
    • intval('4'); //vrátí 4
    • intval('4.98'); //vrátí 4
    • intval('bagr'); //vrátí 0
    • intval('4bagr'); //vrátí 4
    • intval('bagr4'); //vrátí 0
  • print_r($proměnná)
    Funkce vypíše na obrazovku proměnnou – tato funkce je užitečná zejména pro výpis pole při ladění aplikace. Alternativně lze použít také funkci var_dump(), která sice nemá tak pěkný výstup, ale umí vypisovat i objekty.

Funkce pro práci s řetězci

  • echo(řetězec) nebo echo řetězec
    Vypíše řetězec na výstup. Příklady:
    • echo("abcdefgh");
    • echo "abcdefgh";
  • substr(řetězec, počáteční index, [koncový index])
    Vrátí část řetězce zadanou indexem počátečního a koncového znaku, umožňuje zadávání negativních indexů. Funkce nepodporuje UTF-8, pro UTF-8 použijte mb_substr(). Příklady:
    • $ret = substr("abcdefgh", 0, 4); //vrátí 'abcd'
    • $ret = substr("abcdefgh", 0, -2); //vrátí 'abcdef'
    • $ret = substr("abcdefgh", 3); //vrátí 'defgh'
    • $ret = substr("abcdefgh", 3, 4); //vrátí 'defg'
    • $ret = substr("abcdefgh", -2); //vrátí 'gh'
    • $ret = substr("abcdefgh", -5, -2); //vrátí 'def'
  • strlen(řetězec)
    Vrátí počet bajtů v řetězci. Funkce nepodporuje UTF-8, pro UTF-8 použijte mb_strlen(). Příklady:
    • $ret = strlen("abcdefgh"); //vrátí 8
  • str_replace(hledaný řetězec, nahrazený řetězec, řetězec ve kterém proběhne záměna)
    Najde a zamění v zadaném řetězci nějaké podřetězce. Funkce nepodporuje UTF-8. Příklady:
    • $ret = str_replace("cd", "00", "abcdefgh"); //vrátí 'ab00efgh'
  • explode(oddělovač, řetězec)
    Rozdělí zadaný řetězec na podřetězce s použitím oddělovače, výsledek uloží do pole. Příklady:
    • $ret = explode("*", "ab*d*f*h"); //vrátí pole 0 => 'ab'; 1 => 'd'; 2 => 'f'; 3 => 'h'

Funkce pro práci s polem

  • array(prvek, prvek, ...)
    Vytvoří pole. Pokud nejsou zadány indexy pole, pak se pole automaticky indexuje celým číslem od 0. Příklady:
    • $ret = array('hrušky', 'jablka', 'banány');
      Vytvoří pole 0 => 'hrušky'; 1 => 'jablka'; 2 => 'banány'
      Pole je ordinální (indexované celým číslem). Přístup k hodnotě:
      $ret[2]; //vrátí 'banány'
      Přidání položky:
      $ret[] = 'pomeranče'; //index položky bude 3
      $ret[21] = 'mandarinky'; //index položky bude 21
    • $ret = array(0 => 'hrušky', 1 => 'jablka', 2 => 'banány');
      Vytvoří pole 0 => 'hrušky'; 1 => 'jablka'; 2 => 'banány'
    • $ret = array(10 => 'hrušky', 20 => 'jablka', 30 => 'banány');
      Vytvoří pole 10 => 'hrušky'; 20 => 'jablka'; 30 => 'banány'
    • $ret = array('hrušky' => 'ovoce', 'rajčata' => 'zelenina', 'banány' => 'ovoce');
      Vytvoří pole 'hrušky' => 'ovoce'; 'rajčata' => 'zelenina'; 'banány' => 'ovoce'
      Pole je asociativní (indexované řetězcem). Přístup hodnotě:
      $ret['rajčata']; //vrátí 'zelenina';
      Přidání položky:
      $ret[] = 'zelenina'; //index položky bude 0
      $ret['mandarinky'] = 'ovoce'; //index položky bude řetězec 'mandarinky'
  • count(pole)
    Vrátí počet prvků v poli. Příklady:
    • $ret = array('hrušky', 'jablka', 'banány');
      count($ret); //vrátí 3
  • implode(spojovač, řetězec)
    Vytvoří z pole řetězec s použitím zadaného spojovače. Příklady:
    • $ret = implode(", ", array("ab", "d", "f", "h")); //vrátí řetězec "ab, d, f, h"
  • in_array(prvek, pole)
    Zjistí zda je zadaný prvek (hodnota) přítomen v poli. Příklady:
    • $ret = in_array("d", array("ab", "d", "f", "h")); //vrátí true;
    • $ret = in_array("de", array("ab", "d", "f", "h")); //vrátí false;
    Pokud znáte index prvku, je možné použít funkci isset(). Příklady:
    • $pole = array("ab", "d", "f", "h");
    • isset($pole[0]); //vrátí true;
    • isset($pole[12]); //vrátí false;
    • $pole2 = array("ab" => "d", "f" => "h");
    • isset($pole[0]); //vrátí false;
    • isset($pole['f']); //vrátí true;
    Poznámka: pokud pole obsahuje hodnoty null, vrátí pro ně funkce isset() vždy false, v tom případě je nutné použít funkci array_key_exists().

Funkce pro práci s databází (objektové rozhraní)

  • V PHP je možné pro přístup k databázi použít univerzální objektové rozhraní PDO (PHP Database Objects). Pomocí tohoto rozhraní je možné přistupovat k různým DB serverům (PostgreSQL, MySQL, Oracle, …) pomocí stejné sady funkcí
  • PDO(připojovací řetězec, [login], [heslo])
    Konstruktor objektu PDO – připojení k databázi. Prvním parametrem je připojovací řetězec (DSN), který se mírně liší pro jednotlivé DB systémy. Příklady:
    • $db = new PDO('pgsql:host=localhost;dbname=jmenoDatabaze', 'login', 'heslo');
    • Připojení k MySQL vyžaduje nastavení kódování a to jednak na straně klienta (charset v DSN), tak na straně serveru (SET NAMES)
    • $db = new PDO('mysql:host=localhost;dbname=jmeno_databaze;charset=utf8',
      'login', 'heslo', array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8'));
    Host (adresa serveru) je obvykle localhost (nebo 127.0.0.1), ostatní parametry jsou přihlašovací údaje k vaší databázi. Po připojení k databázi je vhodné nastavit způsob řízení chyb databázového rozhraní, to je možné udělat pomocí metody setAttribute():
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    Tímto se nastaví řízení chyb tak, že při chybě při spouštění SQL dotazu bude vytvořena výjimka. Není tedy nutné potom testovat návratové hodnoty následujících funkcí, ale předpokládá to, že kód přistupující k databázi je na vhodném místě obalen try-catch blokem. Například:
    … try {
        $stmt = $db->query("SELECT * FROM osoby");
    … } catch (Exception $e) {
        exit("Nelze spustit dotaz ".$e->getMessage());
    }
  • query(SQL SELECT dotaz) Metoda objektu PDO, která spustí jednoduchý výběrový dotaz (bez parametrů/proměnných) a vrátí jeho výsledek jako objekt PDOStatement. Příklad:
    $stmt = $db->query("SELECT * FROM osoby"); (stmt = statement)
  • query(SQL INSERT/UPDATE/DELETE dotaz) Metoda objektu PDO, která spustí jednoduchý aktualizační dotaz (bez parametrů/proměnných) a vrátí počet změněných řádků. Příklad:
    $pocet = $db->query("DELETE FROM osoby WHERE id_adresy IS NULL");
    echo "Bylo smazáno ".$pocet." osob bez adresy.";
    .
  • fetch([způsob vracení výsledků]) Metoda objektu PDOStatement, která vrátí jeden řádek výsledku dotazu. Příklad:
    while ($row = $stmt->fetch() {
        print_r($row);
    }
    Při spuštění bez parametrů vrací metoda fetch() jednotlivé řádky jako asociativní pole indexované názvy sloupců v databázi. Jinou možností je zadání parametru PDO::FETCH_OBJ, potom bude každý řádek vrácen jako anonymní objekt. Další možnosti jsou popsány v manuálu.
  • rowCount() Metoda objektu PDOStatement, která vrátí počet řádků ovlivněných aktualizačním SQL dotazem, nebo počet řádků vrácených výběrovým dotazem (tato funkce nefunguje na všech DB serverech!). Příklad:
    $stmt = $db->query("SELECT * FROM osoby");
    echo "Nalezeno ".$stmt->rowCount()." osob.";
  • prepare(SQL dotaz) Metoda objektu PDO, která připraví pro spuštění dotaz s parametry (proměnnými). Tato funkce dotaz pouze připraví, nespustí ho!. Před spuštěním je nutné nastavit parametry pomocí následující funkce bindValue()
  • bindValue(název parametru, hodnota parametru, [datový typ]) Metoda objektu PDOStatement, která dosadí hodnotu parametru. První argument funkce je název parametru v SQL dotazu tak, jak je použit v metodě prepare() (např ':id_osoby'). Druhý argument funkce je hodnota, která se má dosadit, hodnota bude automaticky escapována. Pokud bude je zadán třetí argument funkce (datový typ), je hodnota převedena na tento datový typ – nejpoužívanější hodnoty jsou PDO::PARAM_INT a PDO::PARAM_STR. Příklad:
    $stmt = $db->prepare("SELECT * FROM osoby WHERE jmeno=:jmeno AND id_osoby > :id_osoby");
    $stmt->bindValue(':jmeno', $filtr, PDO::PARAM_STR);
    $stmt->bindValue(':id_osoby', 5, PDO::PARAM_INT);
    $stmt->execute();
    Alternativou k této metodě je metoda bindParam(), která umožňuje parametr v SQL dotazu navázat na proměnnou, v tom případě se pak do SQL dotazu dosadí hodnota proměnné v okamžiku spuštění SQL dotazu. Při použití bindValue() se dosadí hodnota proměnné v okamžiku volání bindValue().
  • execute([parametry]) Metoda objektu PDOStatement, která spustí připravený SQL dotaz (viz výše). Metodě je možné přímo předat parametry a nahradit tak volání metody bindValue(). Příklad: $stmt = $db->prepare("SELECT * FROM osoby WHERE jmeno=:jmeno AND id_osoby > :id_osoby");
    $stmt->execute(array(':jmeno' => $filtr, ':id_osoby' => 5));
    Pozor: při použití připravených SQL dotazů (prepared statements) – tedy při použití metody prepare() je nutné vždy zavolat metodu execute(). Metoda execute() musí být volána vždy až po nastavení parametrů.
  • Může se zdát, že použití připravených SQL dotazů (prepared statements) je komplikovanější, než prosté spojování SQL dotazu jako textového řetězce. Motivace pro využití připravených dotazů je jednak zvýšení výkonu (zejména pokud se spouští stejný dotaz vícekrát) a zejména zvýšení bezpečnosti   data (parametry), která jsou vkládána do SQL dotazu jsou oddělena od programu (vlastního SQL dotazu) a jsou správně ošetřena proti SQL injection útoku.

Funkce pro práci s databází PostgreSQL (procedurální rozhraní)

  • pg_connect(připojovací řetězec)
    Připojí se k zadané PostgreSQL databázi, host (adresa serveru) je obvykle localhost (nebo 127.0.0.1). Jiná adresa je pouze v případě, že webový a databázový server jsou jiné počítače. Příklad:
    • $connection = pg_connect('host=localhost user=uzivatel password=heslo dbname=databaze');
      if (!$connection) { //funkce vrátí false pokud se připojení nezdaří – ukončí se skript
          exit('Nefunguje databáze');
      }
  • pg_query([připojení k databázi], SQL dotaz)
    Spustí SQL dotaz, první parametr je připojení získané funkcí pg_connect(). Funkce vrátí výsledek dotazu (tabulku) nebo false, pokud se dotaz nepodaří spustit. Příklad:
    • $query_res = pg_query('SELECT * FROM osoby;');
      if ($query_res) { //funkce resource pointer na výsledek dotazu
          …
      }
  • pg_last_error([připojení k databázi])
    Vrátí text chyby, která nastala při poslední operaci s databází. Příklad:
    • $query_res = pg_query('blablaSELECT * FROM osoby;');
      if (!$query_res) { //funkce vrátí false, pokud se dotaz nepodařilo spustit (pravděpodobně je v něm chyba)
          echo pg_last_error(); //vypíše na obrazovku text ve smyslu 'Cannot exec query, syntax error near blablaSELECT'
      }
  • pg_fetch_array(výsledek dotazu)
    Funkce se používá k výpisu výsledku SELECT dotazu. Pro aktualizační dotazy (INSERT, UPDATE, DELETE) nemá její použití žádný význam. Výsledek dotazu je získaný funkcí pg_query(). Funkce vrací asociativní pole, které obsahuje jeden řádek výsledku dotazu. Indexy prvků v poli jsou názvy sloupců v dotazu (tabulce) a hodnoty jsou hodnoty příslušných buněk daného řádku. Funkce vrací false pokud již vrátila všechny řádky výsledku, nebo pokud výsledek neobsahuje žádné řádky. Příklad:
    • $query_res = pg_query($connection, 'SELECT * FROM osoby;');
      if ($query_res) {
          while ($result = pg_fetch_array($query_res)) {
              print_r($result);
          }
      }
  • pg_result_seek(výsledek dotazu, pozice)
    Funkce najde ve výsledku SELECT dotazu zadaný řádek. Používá se například pokud je potřeba vypsat výsledek jednoho dotazu 2×, nebo vypsat nejdříve první řádek výsledku a potom znovu všechny řádky. Příklad:
    • $query_res = pg_query($connection, 'SELECT * FROM osoby;');
      $radek = pg_fetch_array($query_res); //do proměnné $radek1 uloží obsah prvního řádku
      $radek = pg_fetch_array($query_res); //do proměnné $radek1 uloží obsah druhého řádku
      pg_result_seek($query_res, 0); //vybere první řádek výsledku dotazu
      $radek = pg_fetch_array($query_res); //do proměnné $radek1 uloží obsah prvního řádku

Funkce pro práci s databází MySQL (procedurální rozhraní)

  • mysqli_connect(adresa serveru, uživatel, heslo, název databáze)
    Připojí se k zadané MySQL databázi, adresa serveru je obvykle localhost (nebo 127.0.0.1 - což je totéž). Jiná adresa je pouze v případě, že webový a databázový server jsou jiné počítače. Příklad:
    • $connection = mysqli_connect('localhost', 'uzivatel', 'heslo', 'databaze');
      if (!$connection) { //funkce vrátí false pokud se připojení nezdaří, v tom případě je dobré ukončit skript
          exit();
      }
  • mysqli_query(připojení k databázi, SQL dotaz)
    Spustí SQL dotaz, první parametr je připojení získané funkcí mysqli_connect(). Funkce vrátí výsledek dotazu (tabulku) nebo false, pokud se dotaz nepodaří spustit. Příklad:
    • $query_res = mysqli_query($connection, 'SELECT * FROM osoby;');
      if (!$query_res) {
          …
      }
  • mysqli_error(připojení k databázi)
    Vrátí text chyby, která nastala při poslední operaci s databází. Příklad:
    • $query_res = mysqli_query($connection, 'blablaSELECT * FROM osoby;');
      if (!$query_res) { //funkce vrátí false pokud se dotaz nepodařilo spustit
          echo mysqli_error($connection); //vypíše na obrazovku text ve smyslu 'Cannot exec query, syntax error near blablaSELECT'
      }
  • mysqli_fetch_array(výsledek dotazu)
    Funkce se používá k výpisu výsledku SELECT dotazu. Pro aktualizační dotazy (INSERT, UPDATE, DELETE) nemá její použití žádný význam. Výsledek dotazu je získaný funkcí mysqli_query(). Funkce vrací pole, které obsahuje jeden řádek výsledku dotazu uložený v poli. Indexy prvků v poli jsou názvy sloupců v dotazu (tabulce) a hodnoty jsou hodnoty příslušných buněk daného řádku. Funkce vrací false pokud již vrátila všechny řádky výsledku, nebo pokud výsledek neobsahuje žádné řádky. Příklad:
    • $query_res = mysqli_query($connection, 'SELECT * FROM osoby;');
      if ($query_res) {
          while ($result = mysqli_fetch_array($query_res)) {
              print_r($result);
          }
      }
  • mysqli_stmt_num_rows(výsledek dotazu)
    Funkce vrátí počet řádků ve výsledku SELECT dotazu, pro výsledky aktualizačních dotazů vrací 0. Příklad:
    • $query_res = mysqli_query($connection, 'SELECT * FROM osoby;');
      if ($query_res) {
          $row_count = mysqli_stmt_num_rows($query_res);
      }

Funkce pro práci s regulárními výrazy

  • preg_match(vzor, řetězec, [výsledky])
    Zjistí jestli zadaný řetězec odpovídá zadanému vzoru a případně vrátí část nebo části řetězce, které regulárnímu výrazu odpovídají. Funkce vrátí 1 pokud řetězec vzoru odpovídá nebo 0, pokud řetězec vzoru neodpovídá. Regulární výraz musí být obalen nějakým dalším znakem (v příkladech je to znak #, může se však jednat o libovolný znak, který se nevyskytuje v regulárním výrazu). Modifikátory regulárního výrazu (např. i – case-insensitive) se zapisují za tento uvozující znak. Příklady:
    • preg_match('# [0-9]+#', 've skladu je 42 kedluben'); //vrátí true
    • preg_match('# [0-9]+ KEDLUB#', 've skladu je 42 kedluben'); //vrátí false
    • preg_match('# [0-9]+ KEDLUB#i', 've skladu je 42 kedluben'); //vrátí true
    • preg_match('# ([0-9]+) kedlub#', 've skladu je 42 kedluben', $matches); //vrátí true
      echo $matches[0]; //obsahuje 've skladu je 42 kedluben'
      echo $matches[1]; //obsahuje '42'

      První položka pole $matches je část, řetězce, která odpovídá regulárnímu výrazu. Další položky jsou pak jednotlivé pod-vzory (sub-patterns) – v uvedeném regulárním výrazu je jediný podvzor ([0-9]+). V předchozích regulárních výrazech žádný podvzor uveden není. Pokud regulární výraz začíná znakem ^ a končí znakem $, pak první položka pole $matches obsahuje celý zadaný řetězec.

Poznámka: funkce pro práci se regulárními výrazy (preg_XXX) podporují UTF-8 řetězce pokud zadáte k regulárnímu výrazu modifikátor u. To je velmi podstatná výhoda oproti ostatním PHP funkcím pro práci s řetězci, které většinou UTF-8 nepodporují.

  • preg_match_all(vzor, řetězec, [výsledky])
    Funkce pracuje stejně jako preg_match, nezastaví se však při prvním nálezu vzoru, ale prozkoumá celý řetězec. Tedy – zjistí, jestli zadaný řetězec odpovídá zadanému vzoru a případně vrátí všechny části řetězce, které regulárnímu výrazu odpovídají. Funkce vrátí počet nálezů vzoru v zadaném řetězci. Příklady:
    • preg_match_all('#[0-9]+#', 've skladu je 42 kedluben a 52 hrušek');
      //vrátí 2
    • $i = preg_match_all('# ([0-9])+ [a-z]+#', 've skladu je 42 kedluben a 52 hrušek', $matches);
      echo $i; //vypíše 2
      echo $matches[0][0]; //obsahuje ' 42 kedluben'
      echo $matches[0][1]; //obsahuje ' 52 hru'
      echo $matches[1][0]; //obsahuje '42'
      echo $matches[1][1]; //obsahuje '52'

      Položky v poli jsou standardně řazeny podle nalezených pod-vzorů, tedy $matches[1] je pole všech výskytů prvního pod-vzoru. Toto chování je možné změnit – viz manuál. Všimněte si také, že písmeno 'š', neodpovídá třídě znaků [a-z]. To je způsobené tím, že preg_XXX funkce nepodporují UTF-8, pokud není zadaný modifikátor u. Řešením je použít třídu [:word:] v kombinaci s modifikátorem u.
    • preg_match_all('# ([0-9])+ [[:word:]]+#u', 've skladu je 42 kedluben a 52 hrušek', $matches); //vrátí 2
      echo $matches[0][0]; //obsahuje ' 42 kedluben'
      echo $matches[0][1]; //obsahuje ' 52 hrušek'
      echo $matches[1][0]; //obsahuje '42'
      echo $matches[1][1]; //obsahuje '52'
  • preg_replace(vzor, náhrada, řetězec)
    Nahradí v zadaném řetězci všechny výskyty vzoru zadanou náhradou. Příklad:
    • $string = preg_replace('#([0-9])+#', 'XY', 've skladu je 42 kedluben a 52 hrušek');
      echo $string; // Vypíše 've skladu je XY kedluben a XY hrušek'

Funkce pro práci se soubory

  • file_get_contents(jméno souboru)
    Načte obsah souboru, který je uložený na serveru. Příklady:
    • $ret = file_get_contents('pokus.txt'); //načte obsah souboru pokus.txt uloženého v adresáři se skriptem do proměnné $ret
  • file_put_contents(jméno souboru, obsah souboru)
    Uloží data do souboru, který je uložený na serveru. Příklady:
    • file_put_contents('pokus.txt', 'ahojda'); //uloží do souboru pokus.txt v adresáři se skriptem text 'ahojda'
Tento web používá k poskytování služeb, personalizaci reklam a analýze návštěvnosti soubory cookie. Používáním tohoto webu s tím souhlasíte. Další informace