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í

$a = 5; $b = &$a;
$b = 1; echo $a;

Viditelnost proměnných (a)

Proměnné jsou viditelné pouze v kontextu, ve kterém byly definovány.

global, local, static
superglobal

$p = "globalni promenna";

function f() {
  echo "$p";
}

f();

Viditelnost proměnných (b)

Globální proměnná

$p = "globalni promenna";

function f() {
  global $p;
  echo "$p";
}

f();

Viditelnost proměnných (c)

Lokální proměnná

$p = "globalni promenna";

function f() {
  $p = "lokalni promenna";
  echo "$p";
}

f();

Viditelnost proměnných (d)

Statická proměnná

function f() {
  static $p = 0;
  $p++;
  echo $p;
}

f(); f(); f();

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

String - řetězce (a)

Single quoted

$a = 'single quoted - symbol \', escape \\';
$b = '$a';

Double quoted, simple/complex variable parsing
```
echo "{$a}\n$b";
```

Heredoc

$c = <<<HEREDOC
Tohle je heredoc, hodnota proměnné $a
lze odřádkovat,používat " a '.
HEREDOC;

String - řetězce (b)

Nowdoc - Heredoc, ale neprovádí se náhrady (single quoted)
strcmp($str1, $str2), binárně bezpečná
- 0 - rovnost, 1 - $str1 > $str2, -1 - $str1 < $str2

viz <=>, Strings

Pole

Asociativní vícerozměrná pole
Libovolné typy
Implicitně se pole indexují celočíselně počínaje 0

$arr = [
  "array" => [5, 13 => 9, 8, "a" => 42]
];
$arr = array(
  "array" => array(5, 13 => 9, 8, "a" => 42)
);
echo $arr["array"][0];    // 5
echo $arr["array"][13];   // 9
echo $arr["array"][14];   // 8
echo $arr["array"]["a"];  // 42

viz Array Functions

Přetypování (a)

Implicitní
```
$a = "5";
$a = $a + 5;
echo $a;
```

Explicitní

$numstr = "5";
$number = (int) $numstr;
$number = intval($numstr);

Přetypování (b)

Boolean - 0, '', "" → FALSE, vše ostatní TRUE
Numeric - 1, '1' → 1

Operátory - priorita

Priorita	Operátor	Priorita	Operátor
1	`clone` `new`	12	`&`
2	`[` `array`	13	`^`
3	`**`	14	`\|`
4	`++` `--` `~` `(int)` `(float)` `(string)` `(array)` `(object)` `(bool)` `@`	15	`&&`
5	`instanceof`	16	`\|\|`
6	`!`	17	`??`
7	`*` `/` `%`	18	`?` `:`
8	`+` `-` `.`	19	`=` `+=` `-=` `=` `*=` `/=` `.=` `%=` `&=` `\|=` `^=` `<<=` `>>=`
9	`<<` `>>`	20	`and`
10	`<` `<=` `>` `>=`	21	`xor`
11	`==` `!=` `===` `!==` `<>` `<=>`	22	`or`

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);
$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)

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)

https://www.php.net/releases/8.0/en.php#match-expression

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 (narozdí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) {
    $acc = 0;
    foreach ($numbers as $n) {
        $acc += $n;
    }
    return $acc;
}

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

Funkce - předávání argumetů z pole

… lze použít i opačně

function add($a, $b) {
    return $a + $b;
}

$x = [1, 2];
echo add(...$x);

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);

Funkce - návratová hodnota

Hodnota nebo reference?

function hodnota() {
   static $arr = array(1, 2);
   return $arr;
}
function &reference() {
   static $arr = array(1, 2);
   return $arr;
}
$a = hodnota();
$b = &reference();

$a[] = 3; $b[] = 4;

$a = hodnota();
$b = &reference();

Proměnné funkce

Dynamicky určené jméno funkce, která se má volat

function foo($arg1, $arg2, ..., $argn) { ... }

$func = 'foo';
$func(arg1, arg2, ..., argn);

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

require(cesta), require_once(cesta)
include(cesta), include_once(cesta)