Jdi na navigaci předmětu

Základy jazyka PHP

Vlastnosti PHP

  • Obecně použitelný interpretovaný skriptovací jazyk
    • od počátku zaměřený na web
  • Dynamicky typovaný
  • Objektově orientovaný
  • Rozsáhlá sada dostupných knihoven
    • řetězce, databáze, grafika, reflexe …​
  • Snadno integrovatelný do řady webových serverů
    • modul, CGI/FastCGI
  • Open-source

Syntaxe - hraniční značky

  • Otevírací a zavírací značka <?php a ?>
    • oddělení HTML a PHP
    • text mimo značky se nezpracovává → přímo odesílán klientovi
    • různé varianty značek (<?, <% …​)
  • Příkazy se oddělují znakem ;
  • Blok je ohraničen složenými závorkami { a }
    • za uzavírací závorkou bloku se ; nepíše
  • C-like, BASH-like …​

Syntaxe - komentáře

/**
 Tenhle kousek kodu vypise Hello World
 a my k tomu mame viceradkovy komentar!
*/
echo "Hello World"; // JEDNORADKOVY KOMENTAR

/**
 * Specialni komentar napr. pro PHPDocumentor (~javadoc)
 * @var string $hello
 */
$hello = 'world';

Proměnné

  • Jsou označeny znakem $

    $jmenoPromenne = 5;
    • jména jsou case-sensitive
    • [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
  • Výchozí je přiřazení hodnotou
  • Neinicializované proměnné - výchozí hodnota podle typu
    • FALSE, 0, "", array(), null

Proměnné proměnné

  • Dynamické pojmenování proměnné
  • Použitelné více v OOP
$jmeno = 'promenna';
$$jmeno = 'hodnota';

echo "Promenna pojmenovana: $jmeno
obsahuje hodnotu: ${$jmeno}";

Konstanty

  • Hodnotu během výpočtu nelze změnit
  • Pojmenování - stejná pravidla jako u proměnných
  • Jednoduché datové typy a pole

    const BAR = 'something';
    // historicky, jen mimo tridu
    define('FOO', 'something');
  • Magické konstanty (výběr)
    • __FILE__, __LINE__, __DIR__
    • __FUNCTION__, __CLASS__, __METHOD__

Reference (odkazy)

  • Různá pojmenování pro stejný obsah →
    • jméno proměnné
    • obsah proměnné
  • Nejsou to pointery! Nelze pointerová aritmetika!
  • Přiřazení referencí, předání referencí, návrat referencí (viz 2. cvičení)
$a = 5; $b = &$a;
$b = 1; echo $a;

Proměnné z externích zdrojů

Obsluha HTTP požadavku →

  • řádek požadavku (metoda, URI)
  • HTTP hlavičky (prohlížeč, jazyk, …​)
  • tělo požadavku (POST)

Superglobální pole:

  • $_GET, $_POST, $_COOKIE, $_REQUEST

Potenciálně nebezpečné → kontrola vstupu!

Funkce pro práci s proměnnými

Variable handling Functions

  • isset($prom)
  • empty($prom)
    • TRUE pokud 0, FALSE, NULL, "", []
  • is_numeric($prom)
    • TRUE pokud 0, "0", "0.0", …​
  • is_{bool,integer,float,string,…​}($prom)
  • is_array($prom), is_object($prom)
  • unset($prom)

viz také: get_class, instanceof

Datové typy

PHP je dynamicky typovaný jazyk - datový typ je určen až za běhu!

  • jednoduché - boolean, integer, float, string
  • složené - pole, objekt
  • speciální - resource, NULL
  • pseudotypy (dokumentace) - mixed, number, callback

Jednotlivé typy, jejich literály a přetypování jsou popsány na samostatné stránce Datové typy a výrazy.

Operátory - priorita

  • úplná tabulka priorit a asociativity: referenční dokumentace
  • čeho si všimnout oproti C++:
    • má vyšší prioritu než unární -, tzn. -2 2 je -4
    • od PHP 8 má . nižší prioritu než + a -, tzn. "a" . 1 + 2 je "a3"
    • and, or a xor mají nižší prioritu než =, tzn. $x = true and false uloží do $x hodnotu true
    • porovnávací operátory nejsou asociativní, tzn. 1 < 2 < 3 je syntaktická chyba
  • v nejasných případech závorkujte

Operátory - porovnání

  • rovnost $a == $b, resp. nerovnost $a != $b
    • porovnává se pouze hodnota nikoliv datový typ
    • u objektů se porovnávají hodnoty atributů
  • identita $a === $b, resp. neidentita $a !== $b
    • porovnává se nejen hodnota ale i datový typ
    • u objektů se porovnávají reference (identický objekt)

Operátor .

  • operátor zřetězení
  • neobvyklé oproti jiným jazykům
echo "Zpracovano " . count($rows) . " radek\n";

Operátor @

potlačení chybové zprávy

@mkdir("data/$user", 0755);

Operátor <=>

  • spaceship operator
  • princip strcmp
"ahoj" <=> "svete"  // -1
5 <=> 3             // 1
"7" <=> 7           // 0

Operátor ?:

  • elvis operator
  • výsledkem je první operand pokud je TRUE, jinak druhý operand
  • $a ?: $b je zkratka za ternární výraz $a ? $a : $b
null ?: 'fail'   // fail
5 ?: 2           // 5

Operátor ??

  • null coalescing operator
  • výsledkem je první operand pokud vyhoví isset tj. existuje a není NULL
$imageData = json_decode($content, true);
$width = $imageData['width'] ?? 100;

Řídící struktury

  • větvení - if/elseif/else, switch
  • cykly - while, for, foreach, break, continue
  • require/require_once, include/include_once

Větvení (a)

if ($a > $b)
    echo "a is bigger than b";
elseif ($a == $b) {
    echo "a is equal to b";
}
else
    echo "a is smaller than b";

Větvení (b)

  • proměnná je s jednotlivými hodnotami porovnána pomocí == (typově nestriktní porovnání)
switch ($i) {
    case 0:
        echo "i equals 0";
        break;
    case 1:
        echo "i equals 1";
        break;
    case 2:
        echo "i equals 2";
        break;
}

Větvení (c) - match (PHP 8)

  • Referenční dokumentace
  • oproti switch:
    • používá typově striktní porovnání, tzn. "0" a 0 jsou dvě různé větve
    • vrací hodnotu (switch pouze provádí kód)
  • výchozí větev default
    • volitelná; není-li zahrnuta, match vyhodí výjimku, pokud neodpovídá žádná explicitní větev
echo match ($i) {
    0 => "i equals 0",
    1 => "i equals 1",
    2 => "i equals 2"
};

Cykly (a)

$i = 10;
while ($i < 10) {
    echo $i++;
}
$i = 10;
do {
    echo $i++;
} while ($i < 10);

Cykly (b)

for ($i = 1; $i <= 10; $i++) {
    echo $i;
}
  • vyskočení z cyklu/switch - break [n]
  • další iterace - continue [n]

Cykly (c)

$arr = array (
  'k1' => 1, 'k2' => 2, 'k3' => 3);
foreach ($arr as $key => $value)
  echo "$key: $value";
$arr = array(1, 2, 3, 4);
foreach ($arr as &$value)
    $value = $value * 2;

print_r($arr);

Funkce

  • Pojmenování - obdobně jako proměnné, case-insensitive (na rozdíl od proměnných)
  • Definice → použití
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
{
    echo "Example function.\n";
    return $retval;
}

foo(1, 2, ..., n);

Funkce - předávání argumentů (a)

  • Hodnotou (implicitní)

    function f1($i) {
        $i[0] = 100;
    }
    $x = [1, 2];
    f1($x);
  • Odkazem

    function f1(&$i) {
        $i[0] = 100;
    }
    $x = [1, 2];
    f1($x);

Funkce - proměnlivý počet argumentů

Pomocí …​

function sum(...$numbers) {
    // $numbers je pole předaných argumentů
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

echo sum(1, 2, 3, 4);

Funkce - předávání argumentů (b)

  • Argument může mít výchozí hodnotu
    • musí být na konci, lze jej vynechat
    • lze použít jednoduché datové typy, pole a NULL
  • PHP nepodporuje přetěžování funkcí
function p($n, $e = 2)
{
    return $n ** $e;
}

echo p(4);
echo p(3,3);

Další vlastnosti funkcí (deklarace typů, návratové hodnoty, kontext proměnných, anonymní funkce, …​) jsou náplní 2. cvičení.

Načítání a vykonání externích souborů

  • require(cesta), require_once(cesta)
  • include(cesta), include_once(cesta)
  • require = načíst soubor, při jeho neexistenci skončit tvrdou chybou
  • include = načíst soubor, při jeho neexistenci skončit varování
  • _once = pokud byl soubor již načten, podruhé načíst nezkoušej
    • jinak může dojít k chybě typu Fatal error: Cannot redeclare class Foo