FIT ČVUT Course Pages
BI-PHP — Programování v PHP
Jdi na navigaci předmětu

01 - Základní syntaxe a datové typy

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

PrioritaOperátorPrioritaOperátor
1clone new12&
2[ array13^
3**14|
4++ -- ~ (int) (float) (string) (array) (object) (bool) @15&&
5instanceof16||
6!17??
7* / %18? :
8+ - .19= += -= *= **= /= .= %= &= |= ^= <<= >>=
9<< >>20and
10< <= > >=21xor
11== != === !== <> <=>22or

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)

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)

Datové typy a výrazy

Pravdivostní hodnoty

  • TRUE, FALSE
  • case insensitive

  • explicitní konverze

    (bool) (boolean)

  • implicitní konverze

    0, "", [], null → FALSE

Celá čísla (integer)

  • se znaménkem, 32- or 64-bit, znaménko (+ nebo -)
  • base 16 (0xA), 10 (10), 8 (012), 2 (0b1010)
  • PHP_INT_SIZE, PHP_INT_MAX, PHP_INT_MIN (PHP 7.0)
  • při overflow automaticky konverze na float

Čísla s plovoucí desetinou čárkou (float)

  • podle normy IEEE 754, mantisa + exponent
  • ztráta přesnosti
  • nevhodné přímo porovnávat rovnost

Práce s čísly - konverze

Práce s čísly

  • ztráta přesnosti!

    floor((0.1+0.7)*10);    // 7
intval(19.99*100)       // 1998

  • porovnání desetinných čísel, pomocí == nevhodné

    $a = 1.23456789; $b = 1.23456780;
// presnost
$epsilon = 0.00001;
if (abs($a-$b) < $epsilon) ...

Řetězce

  • single quoted, nowdoc

    $string = '$string';
$string = <<<'END'
Variables are not expanded in nowdoc, try it:
$string = $string;
END;

  • double quoted, heredoc

    $string = "$string"; //empty string
$string = <<<END
Variables are expanded in heredoc, try it:
\$string = $string;
END;

Práce s řetězci - parsování proměnných

  • jednoduchá syntaxe - "$variable"
  • komplexní syntaxe - "{$variable}"
    • umožňuje složitější výrazy např. volání funkcí
$numbers = [1 => 1, 2, 3];
echo "$numbers[2]";

function f()
{
return 'colors';
}

$colors = ['blue' => 0x0000FF, 'green' => 0x00FF00, 'red' => 0xFF0000];
echo "{${f()}['green']}";

Práce s řetězci - přístup po znacích

  • [index] - nefunguje s multibyte řetězci!

    $string = 'abcde';
echo "{$string[0]}"; // => a
  • mb_substr()

viz také: substr(), substr_replace(),

Práce s řetězci - interní reprezentace

  • pole bytů, vnitřně kódováno v ISO-8859-1 (Latin1)
  • některé funkce nefungují s multibyte řetězci! - např. strlen(), strpos()
  • rozšíření pro multibyte - mbstring, obvykle vestavěné

viz Details of string type

Práce s řetězci - konverze

Pole

  • uspořádaná mapa - klíč ⇒ hodnota
  • automatické indexy (klíče) od 0 nebo jako asociativní pole
  • použití
    • vektor
    • hash tabulka, slovník

Pole - literál

$array = [
    "foo" => "bar",
    42    => 24,
    "multi" => [
         "dimensional" => [
             "array" => "foo"
         ]
    ]
];

původní syntaxe array( …​ ), od PHP 7 pohodlnější [ …​ ]

Práce s polem - základní operace

  • přidání prvku
    • na konkrétní místo - $a[10] = …​
    • na konec pole - $a[] = …​
  • test existence - isset($a[10])
  • odstranění prvku - unset($a[10])

Práce s polem

  • konverze na pole - explicitně (array)
  • porovnání
  • přiřazení (kopírování)
    • hodnotou - $b = $a;
    • referencí (explicitně) - $b = &$a;

Práce s polem

  • Array functions
    • iterování - current, next, end, reset
    • test existence hodnoty - in_array
    • test existence klíče - array_key_exists
    • řazení - sort, asort, ksort …​
    • sloučení/rozdělení - array_merge, array_merge_recursive, array_slice
    • fronta/zásobník - array_push, array_pop, array_shift, array_unshift
    • mapování - array_map, filtrování - array_filter
    • …​