PHP

PHP (енгл. Hypertext Preprocessor) специјализовани је скриптни језик првенствено намењен за израду динамичног веб садржаја и изводи се на страни сервера.

PHP
PHP логотип
Изговара се	пе-ха-пе
Модел	императивни, објектно-оријентисан
Појавио се	1995. (1995)
Аутор(и)	Расмус Лердорф
Дизајнер(и)	The PHP Group
Актуелна верзија	7.2.7
Датум актуелне верзије	21. јун 2018. (2018-06-21)
Систем типова	динамички, слаби
Утицаји	C, Перл, Јава, C++, C#, Пајтон
Утицао на	Php4delphi, Фалкон, Хак
Оперативни системи	Више-платформски
Лиценца	PHP лиценца
Веб-сајт	php.net
Документација	php.net/docs.php

Увод

PHP је стекао популарност због своје једноставности и синтаксе наслеђене из програмског језика C. Током времена језик се проширивао и стицао могућности за објектно оријентисано програмирање, нарочито од верзије 5.0. Наликује језику C++ у смислу што дозвољава и чисто-процедурално програмирање, али истовремено омогућава и коришћење класа и других концепата објектно оријентисаног програмирања (наслеђивање, апстрактне класе и методе, интерфејсе итд.).

Историја

PHP/FI

Расмус Лердорф

Енди Гутманс

Зеев Сураски

PHP представља наследника алата по називу PHP/FI, написаног 1994. године од стране Расмуса Лердорфа. PHP/FI је представљао скуп алата написаних у Перлу, и аутор га је користио за сопствене потребе. Скуп алата је добио име "алати за личну презентацију" (енгл. Personal Home Page Tools), одакле и скраћеница PHP. Како су расле потребе на сајту, аутор је преписао комплетан пројекат у C-у и омогућио да може да комуницира са базама података а корисницима свог сајта да направе сопствене презентације помоћу њега. Расмус је потом објавио своје алате и учинио изворни код доступан свима да би се пројекат брже развијао и да би се грешке (багови) брже исправљале.

PHP/FI, чија је пуна дефиниција гласила „алати за личну презентацију/преводилац образаца“ (енгл. Personal Home Page Tools/Forms Interpreter) је имао само неке ствари заједничке са данашњим PHP-ом — променљиве као у Перлу, аутоматско рашчлањивање променљивих из захтева и уграђени HTML. PHP/FI 2.0 је коначно и званично објављен 1997. године, да би га убрзо заменио PHP 3.0.

PHP 3.0

PHP 3.0 је представљао прву верзију која доста личи на данашње верзије PHP-а. Креирали су га израелски програмери Зеев Сураски и Енди Гутманс са факултета Техникон, као потпуну прераду пројекта PHP/FI. Открили су да је он имао озбиљне недостатке и да није могао задовољити њихов универзитетски пројекат електронске трговине. У сарадњи са Ледорфом су објавили PHP 3.0 као званичног наследника језика PHP/FI, а његов развој је заустављен.

Главна особина нове верзије језика је била његова проширивост, која је привукла бројне програмере широм света да додају нове могућности. Поред квалитетне подршке за разне врсте база података, верзија 3.0 је увела и могућност објектно оријентисаног програмирања и већу конзистентност у језичкој синтакси.

Име је промењено у PHP (без додатка "FI"), чије се значење изменило да представља рекурзивни акроним "PHP: препроцесор хипертекста" (PHP: Hypertext Preprocessor).

PHP 3.0 је званично објављен у јуну 1998. након девет месеци коришћења у пробној фази.

PHP 4.0

У зиму 1998. Зеев и Гутманс су започели поновно писање PHP-а испочетка, покушавајући да поправе језгро тако да би боље радило са већим апликацијама и да би побољшали модуларност. Ново језгро су назвали Зенд машина (Zend engine), по деловима својих имена Зеев и Енди, да би касније формирали и Zend Technologies у Рамат Гану, Израел, која надгледа унапређење PHP-а. Ново језгро је успешно довршено и појавило се у јавности средином 1999, а нова верзија PHP-а, 4.0, опремљена новим језгром је званично објављена у мају, 2000. Поред бољих перформанси, нова верзија је укључивала и кеширање стандардног излаза, сесије, бољу подршку за различите веб-сервере, сигурнији пренос корисничких података и неколико нових контролних структура.

PHP 5.0

Верзија 5.0 је изашла у јулу 2004. године, након дугог развоја и неколико пробних верзија. Користи језгро Зенд машина 2.0 са новим објектним моделом и много нових могућности.

Верзија 5 је такође донела мноштво измена у објектно-оријентисаном програмирању.

PHP 7.0

Верзија 7.0 је изашла у децембру 2015. године.

Употреба

Иако се PHP може користити за програмирање конзолних апликација и графичких интерфејса (библиотека PHP-GTK), његова основна и главна употреба је у програмирању динамичних страница на Интернету.

До 1997. PHP је стекао неколико хиљада корисника; до 1998. број сајтова на којима је инсталиран PHP 3.0 је порастао на пар стотина хиљада а број корисника истог на пар десетина хиљада. Данас PHP користи неколико стотина хиљада програмера и неколико милиона сајтова укључујући неке од најпосећенијих сајтова на свету, попут Фејсбука, Википедије, Јахуа, Јутуба и Флицкра.

Начин извршења

Извршавање PHP скрипте на веб-серверу

Програм који се напише у PHP-у не захтева превођење (компајлирање), него се интерпретира при сваком извршавању. PHP интерпретатор може радити по PHP CGI принципу, односно тако што ће интерпретатор постојати као екстерна апликација, која се позива да изврши дату скрипту сваки пут кад буде захтевана од неког корисника, а може бити инсталиран и као модул веб-сервиса. Друга варијанта је данас у највећој употреби јер пружа знатно већу брзину извршавања — интерпретатор је на тај начин увек учитан у меморију те се не мора позивати спољашњи програм.

Уобичајен сценарио по ком се извршавају PHP скрипте је следећи:

• клијент (корисник Интернета који користи неки интернет прегледач) захтева PHP страницу са сервера
• сервер прослеђује захтев сервису за веб (програм веб-сервер на серверу)
• веб-сервер препознаје да се тражи PHP датотека
• не шаље његов садржај клијенту, него га извршава као програм помоћу PHP модула
• излазни текст програма (стандардни излаз) се шаље клијенту као резултат захтева
• клијент препознаје врсту резултата (HTML код, слика, PDF садржај, архива итд.)
• резултат се приказује клијенту на одговарајући начин

Структура програма

За разлику од већине програмских језика који поседују почетну функцију (main у C-у, први блок BEGIN и Паскалу, класа са main методом у Јави итд.), PHP датотека, налик на већину скриптних језика, једноставно садржи скуп наредби, које се извршавају једна за другом, од прве до последње, где се последња уједно сматра и крајем PHP програма.

Структура PHP скрипта

PHP датотеке могу да садрже следеће врсте елемената:

• HTML ознаке
• Ознаке за PHP
• PHP наредбе
• белине
• коментаре

Постоје четири стила за исписивање PHP ознака:

• XML стил уз помоћ већ поменутих ознака <?php и ?> и такав стил се препоручује, а обавезан је када је PHP код усађен у HTML код. У специјалном случају дозвољава се да последња ознака ?> у задњој PHP скрипти не буде наведена.
• скраћени стил између ознака <? и ?>. Може да се користи у колико се у конфигурацијској датотеци php.ini активирана опција short_open_tag, али се његова употреба не препоручује зато што у неким окружењима није подржан. Међутим, од верзије 5.4, скраћени стил у облику <?= ... ?> је омогућен без обзира на подешавања унутар конфигурацијске датотеке, а служи као замена за <?php ... ?>.
• скрипт стил између ознака <script language="php"> и </script>, је дужа верзија XML стила и обично се препоручује када се истовремено користе и други скриптни језици, посебно ако HTML едитор прави проблеме.
• ASP стил између ознака <% и %> представља још једну скраћену верзију. Најчешће се користи у ASP и ASP.NET окружењу, али је неопходно претходно активирати опцију short_open_tag у конфигурацијској датотеци php.ini. Такође се не препоручује.

Под белинама или белим просторима (енгл. white spaces) се подразумевају знакови за раздвајање, као што су ознаке за повратак на почетак реда, размаци и табулатори. Интерпретатори за HTML код и PHP изворно окружење занемарују ове просторе.

PHP наредбе „угњежђавају“ се у заглавље (енгл. header) и/или тело (енгл. body) веб стране на следећи начин:

<?php

PHP наредбе

?>

Уколико нека страна садржи PHP скрипту, требало би да носи наставак .php, како би веб сервер био обавештен о њиховом постојању.

У PHP датотеци, блок који је окружен језичким структурама, које започињу HTML ознаком (енгл. tag) <?php, а завршавају се ознаком ?>, се сматра PHP кодом и извршава се помоћу PHP интерпретатора (тумача), док се остатак кода — ван ових ознака — сматра хипертекстом, који једноставно треба да се испише на стандардни излаз, без интерпретирања. Следи пример једног PHP програма:

<!-- наредни део написан у HTML-у се преписује директно на стандардни излаз -->
<html>
<body>
    <p>
        <!-- наредни део припада PHP блоку, те се извршава -->
        <?php
            echo "Здраво свете!";
        ?>
<!-- наредни део до краја кода се такође преписује директно на стандардни излаз -->
    </p>
</body>
</html>

Тумач за PHP код потпуно игнорише празан простор између наредби, тако да његова употреба зависи од личног избора програмера и само доприноси визуелној прегледности исписаног кода. Крај сваке наредбе обележава се тачком са запетом. На овај начин, претходни пример ће на стандардном излазу приказати следећи текст:

<!-- наредни део написан у HTML-у се преписује директно на стандардни излаз -->
<html>
<body>
    <p>
        <!-- наредни део припада PHP блоку, те се извршава -->
        Здраво свете!<!-- наредни део до краја кода се такође преписује директно на стандардни излаз -->
    </p>
</body>
</html>

што представља HTML код спреман за приказ у интернет прегледачу.

PHP код може бити организован у функције и класе, и може се организовати у више датотека. Као почетна датотека, тј. датотека чије наредбе се извршавају прве, се узима она датотека која се да интерпретатору на извршавање. Уколико датотека није наведена, сервер ће аутоматски покушати да покрене датотеку index.php.

Основна синтакса

Коментари

Коментари се могу писати иза две косе црте // или симбола # ако су једноредни (налазе се у истом реду), или између симбола /* и */ за једноредне и вишередне коментаре.

<?php

echo ”Проба за једноредни коментар”; // Ово је једноредни коментар

/* Ово је коментар
                  исписан у два реда */

echo ”Још један једноредни коментар”; # Ово је једноредни коментар
 
?>

Променљиве

Променљиве (енгл. variables) у PHP језику се представљају помоћу знака $, иза кога следи име променљиве. Име мора да почне словом или доњом цртом _ иза којег може да следи неограничен број слова, бројева или доњих црта, при чему се словом сматра слово латинице [A-Z], [a-z] или било који знак са ASCII кодом већим од 127. Тумач за PHP разликује велика од малих слова, па тако променљива $А није исто што и променљива $а.

Променљиве се не декларишу, а њихов тип се одређује према вредностима које им се у изразима додељују током програма, те постоји могућност да се тип променљиве промени.

PHP има следеће типове променљивих:

• Основни типови променљивих:
  • boolean — логичке вредности: тачно — true и нетачно — false
  • integer — цели бројеви
  • float — реални бројеви са покретном запетом
  • string — низ (ниска) знакова (симбола), односно текст (литерал)
• Сложени типови променљивих:
  • array — низ
  • object — објекат
• Посебни типови променљивих:
  • resource — ресурс, садржи упућивач на спољашњи ресурс, нпр. датотеку или веза са базом података
  • NULL — променљива нема вредност, може садржати само вредност null

Није неопходна додела почетних вредности, мада се препоручује, ради прегледности, безбедности и бољег разумевања кода, с обзиром да се њиховом применом у изразима који садрже мешовите типове података, могу добити различити резултати. Тако нпр:

<?php

$a = 1.2;
$b = 2;
$b = $a + $b;

?>

променљива $b у почетку је цео број, а затим се претвара у реалан број са једном децималом (3.2). Осим додељивања вредности имплицитно, промена типа променљиве се може извршити експлицитном конверзијом, тако што се испред имена упише тип променљиве, између заграда. Пример:

<?php

$a = 1.2;
$b = 2;
$b = (int)$a + $b;

?>

У овом случају променљива $b добија вредност 3. При томе се код променљиве $а неће променити ни тип, ни вредност.

Корисне функције

За исписивање променљивих на стандардни излаз користе се две основне функције:

• print ( $arg )
• echo ( $arg1 [, $arg2 ... ] )

Обе су језички конструктори, па се при њиховом позивању не морају користити заграде. Разлика између једне и друге функције је у томе што функцији print може да се проследи само један аргумент, док echo може да штампа више њих одједном, тако да што при позиву променљиве стоје међусобно раздвојене запетом. Променљиве свих типова биће претворене у тип string приликом исписивања.

За испитивање да ли је нека променљива празна, односно да ли има додељену вредност, користи се функција empty. За испитивање да ли нека променљива има почетну вредност, односно да њена вредност није null, користи се функција isset. Ако се функција проследи више од једне променљиве, враћа вредност тачно само у случају да ни једна од променљивих празна. Испитивање променљивих извршава се слева надесно и завршава се у случају да наиђе на прву променљиву која је празна, јер у том случају враћа вредност нетачно.

Елиминисање променљиве врши се помоћу функције unset. Понашање ове функције у великој мери зависи од врсте променљиве и места одакле је позвана. Нпр. у колико се позове унутар блока неке корисничке функције, биће елиминисана вредност само локалне променљиве. За промене вредности глобалних променљивих препоручује се употреба низа $GLOBALS

За структурно приказивање на излазу типа и вредности променљиве, користи се функција var_dump. Функција је посебно корисна у току развоја програма. Пример:

<?php
$b = 3.55;
$c = true;
var_dump($b, $c); // на излазу ће приказати: float(3.55) bool(true)
?>

Испитивање типа променљивих

За испитивање типа променљивих могу се користити функције из табеле:

Испитивање типа променљивих
функција	испитује да ли је
is_array	променљива низ
is_double, is_float, is_real	променљива у формату са покретном запетом
is_long, is_int, is_integer	променљива цео број
is_string	променљива знаковни низ
is_object	променљива објекат
is_resource	променљива ресурс
is_null	променљива има вредност null
is_scalar	променљива скаларног типа: нумерички, логички или знаковни податак
is_numeric	променљива број или знаковни низ који се може претворити у број
is_callable	вредност променљиве име постојеће функције

Константе

За разлику од променљивих, константе се пишу без симбола $. Правило за имена константи је исто као и за променљиве. Мада није неопходно, константе се обично пишу великим словима, а њихове вредности се додељују на следећи начин:

define("НАЗИВ_КОНСТАНТЕ_ВЕЛИКИМ_СЛОВИМА", вредност [, осетљивост_на_мала_и_велика_слова]);

Једном дефинисана константа, не може да мења вредност. Константама је могуће доделити искључиво скаларне вредности, већ поменутих основних типова података (boolean, integer, float и string). Пример:

<?php

define("KONST_BAZA_PODATAKA", "mysql");
echo KONST_BAZA_PODATAKA; // prikazuje "mysql"

?>

Овај начин дефинисања може да се користи на глобалном нивоу, али не и у оквиру блокова структура, појединачних функција, метода или класа, па се у тим случајевима користи кључна реч const.

<?php

define(”MIN_VREDNOST”, "0.0"); // Правилно дефинисање константе ван класе
define(”MAX_VREDNOST”, "1.0"); // Правилно дефинисање константе ван класе

//const MIN_VREDNOST = 0.0; Неправилно дефинисање константе ван класе
//const MAX_VREDNOST = 1.0; Неправилно дефинисање константе ван класе

class ClasaKonstanta
{
    //define(”MIN_VREDNOST”, ”0.0”);        Неправилно дефинисање константе у оквиру класе није дозвољен
    //define(”MAX_VREDNOST”, ”0.0”);        Неправилно дефинисање константе у оквиру класе није дозвољен
  
    const MIN_VREDNOST = 0.0;            // Правилан начин за дефинисање константе унутар класе
    const MAX_VREDNOST = 1.0;            // Правилан начин за дефинисање константе унутар класе

    public static function getMinVrednost()
    {
        return self::MIN_VREDNOST;
    }
    public static function getMaxVrednost()
    {
        return self::MAX_VREDNOST;
    }
}
?>

За добијање вредности одређене константе користи се функција constan(), којој се прослеђује име константе, а као резултат враћа вредност константе или null ако константа није дефинисана.

За добијање вредности свих дефинисаних константи може се користити функција get_defined_constants. У PHP језику постоји велики број већ предефинисаних константи, које могу слободно да се користе у било ком делу програма.

Изрази

Изрази (енгл. еxpressions) су један од основних појмова сваког вишег програмског језика, па и PHP-a. Израз рачуна и даје резултат или узрокује неку активност (звану бочни ефекат). То су комбинације оператора и операнда. Једноставније речено, израз је све оно што има неку вредност. Вредност неког израза одређује се на основу синтаксе израза, односно правила првенства сваког од оператора у изразу и асоцијативности.

Оператори

Оператори су симболи који омогућавају извршавање операција над вредностима и променљивама. Могу имати један, два или више аргумената. Постоје:

• аритметички оператори: сабирање (+), одузимање (-), множење (*), дељење (/), модуло (%).
• оператор за придруживање знаковних променљивих је тачка (нпр. ако је $А = ”једем” , $B = " " и $C = "сарму", као резултат операције $A . $B . $C добија се текст ”једем сарму”)
• оператор доделе (=) и комбиновани оператори доделе

Комбиновани оператори доделе
оператор	употреба	значење
++	$a++	$a = $a + 1
--	$a--	$a = $a — 1
+=	$a += $b	$a = $a + $b
-=	$a -= $b	$a = $a — $b
*=	$a *= $b	$a = $a * $b
/=	$a /= $b	$a = $a / $b
%=	$a %= b	$a = $a % $b
.=	$a .= b	$a = $a . $b

Оператори увећања (++), и умањења (--) у изразима се могу применити префиксно или суфиксно . У зависности од положаја оператора у односу на променљиву, могу се добити различити резултати. Нпр.

$x = ++$a; — прво увећава променљиву $а за 1: $a = $a + 1;, а затим додељује њену вредност променљиву $x: $x = $a; $x = $a++; — прво додељује вредност променљиве $a променљивој $x: $x = $a;, а затим увећава променљиву $a за један $а = $a + 1;

• оператори поређења за који као резултат поређења израза враћају вредности тачно (true) или нетачно (false)

Оператори поређења
оператор	назив	употреба
==	једнако	$a == $b
===	идентично (тип и вредност)	$a === $b
!=	није једнако (различито)	$a != $b
<>	није једнако (различито)	$a <> $b
!==	није идентично	$a !== $b
<	мање од	$a < $b
>	веће од	$a > $b
<=	мање или једнако	$a <= $b
>=	веће или једнако	$a >= $b

• логички оператори поређења, такође враћају вредности тачно (true) или нетачно (false). Осим оператора из табеле могу да се користе и логички оператори нижег приоритета NOT (уместо !), AND (уместо &&), OR (уместо ||), као и оператор XOR за искључиву дисјункцију са вредношћу тачно (true) ако су један оператора или оба нетачни.

Логички оператори
оператор	назив	употреба	резултат
!	негација	!$a	израз тачан ако је $а нетачно
&&	конјункција	$a && $b	тачан ако су $а и $b тачни
||	дисјункција	$a	$b	тачан ако је $а или $b тачно

• оператори над битовима (енгл. bitwise operators) омогућавају да се цео број обрађује као група битова којим је број представљен у меморији. У PHP немају велику примену.

Логички оператори
оператор	назив	употреба	резултат
&	конјункција	$a & $b	битови активни у $a и $b активни су и у резултату
|	дисјункција	$a | $b	битови активни у $a или у $b активни су и у резултату
~	негација	~$a	битови активни у $a нису активни у резултату и обрнуто
^	искључива дисјункција	$a ^ $b	битови активни или у $a или у $b, али не у оба, активни су и у резултату
<<	померање битова улево	$a << $b	помера битове у $a улево за $b места
>>	померање битова удесно	$a >> $b	помера битове у $a удесно за $b места

• условни оператор има следећи облик:

(услов) ? (израз1) : (израз2) — ако је услов испуњен (тачан) враћа се вредност првог израза, а ако није тачан, враћа се вредност другог израза

• оператор занемаривања грешке @, може се употребити испред било ког израза (осим у дефиницијама функција, класа и структурама контроле), при чему се игноришу поруке о грешци. Ипак, у колико је укључена опција track_errors из конфигурацијске датотеке php.ini, последња грешка ће бити забележена у глобалној променљивој $php_errormsg
• оператор извршења — пар инверзних полунаводника `` (енгл. backticks). Све што се постави између њих PHP покушава да изврши као наредбу задату на командној линији сервера. Исту акцију обавља и функција shell_exec, која мора бити искључена. Пример:

<?php
$naredba = `ls -lrt`; //листа садржај текућег директоријума по датуму
echo "<pre>$naredba</pre>"; //резултат се може вратити некој променљивој или послати директно на стандардни излаз
?>

• остали оператори: запета за раздвајање аргумената или параметара функције и за раздвајање елемената листе, оператор за прављење објеката new и приступању његовим члановима ->. итд

Приоритет оператора

Када у једном изразу постоји комбинација више оператора, оне се извршавају редоследом који зависи од њихових приоритета и асоцијативности. Редослед приоритета је:

Приоритет	Оператори	Асоцијативност
1.	Оператори clone и new	неасоцијативни
2.	Оператор низа: [	слева
3.	Оператори инкрементирања и инкрементирања: ++ --	неасоцијативни
4.	Битско не: ~ Унарно минус: - Оператори промене типа податка: (int) (float) (string) (array) (object) (bool) Оператор неисписивања грешке: @	здесна
5.	Оператор instanceof	неасоцијативни
6.	Логичко не: !	здесна
7.	Аритметички оператори: * / %	слева
8.	Аритметички оператори: + - Оператор за придруживање ниски: .	слева
9.	Оператори померања битова: << >>	слева
10.	Оператори провере неједнакости: < <= > >= <>	неасоцијативни
11.	Оператори провере једнакости: == != === !==	неасоцијативни
12.	Битско и: &	слева
13.	Битско ексклузивно или: ^	слева
14.	Битско или: |	слева
15.	Логичко и: &&	слева
16.	Логичко или: ||	слева
17.	Условни оператор: ? :	слева
18.	= ^= <<= >>= =>	здесна
19.	Логичко и: and	слева
20.	Логичко ексклузивно или: xor	слева
21.	Логичко или: or	слева
22.	Запета: ,	слева

Осим наведених оператора, највећи приоритет има мала заграда (), са редоследом од унутрашњих, ка спољашњим.

Пример: У изразу:

$x = 7/2 + 2*3;

се налази 4 оператора: оператор доделе вредности (=) и три аритметичка оператора. Оператори у изразу ће се применити по следећем редоследу:

1. дељење 7/2 и добиће се резултат 3.5
2. множење 2*3 и добиће се резултат 6
3. резултати прве две операције ће се сабрати и добиће се резултат 9.5
4. овај резултат доделиће се променљивој $x

Асоцијативност оператора

Асоцијативност одређује којим редоследом ће се извршавати оператори који су истог приоритета. На пример, у изразу:

6 / 2 * 3

оператори / и * су истог приоритета и асоцијативни слева па ће се применити по следећем редоследу:

1. дељење 6/2 и добиће се резултат 3
2. множење 3*3 и добиће се резултат 9

(Када би оператори били асоцијативни здесна, добио би се резултат 1.)

Са друге стране, у програму:

$b = 1;
$c = 2;
$a = $b = $c; //трећи ред

у трећем реду, оператори доделе = су асоцијативни здесна па ће се применити овим редоследом:

1. додела вредности $c, што је 2, променљивој $b и добиће се резултат 2
2. додела резултата 2 променљивој $a и добиће се резултат 2

На крају извршења програма све променљиве ће имати вредност 2.

Неасоцијативни оператори се уопште не могу користити на овај начин. На пример, код:

$a == $b == $c

није исправан и за резултат ће имати грешку. Уколико се жели проверити међусобна једнакост три променљиве, ови оператори се морају груписати по два, на пример:

$a == $b && $b == $c

Наредбе

Наредбе (енгл. statements) или искази одређују неку акцију. Свака PHP скрипта је састављена од низа наредби. По правилу наредбе се извршавају оним редом којим су наведени у програму, али овај редослед може да се промени неком од наредби за пренос тока програма, при чему пренос може ићи на било који други део програма или ван њега. Основни облик наредбе је израз иза кога следи знак тачка са запетом, као завршни знак наредбе.

Сложена наредба или блок наредба је механизам који групише скуп наредби у једну семантичку целину. Блокови могу да буду уклопљени и сваки може да садржи своје сопствене декларације, иницијализације и извршне наредбе.

Управљачке структуре

Наредбе којима се одређује ток извршавања под одређеним условима, могу да се групишу у једну засебну структуру. Оваква структура се поставља између витичастих заграда: { и }. Управљачке структуре, саме за себе, такође представљају једну наредбу у облику блока. Користе се различити облици управљачких (контролних) структура (енгл. control structure), које се међусобно разликују по начину испитивања услова.

Условно гранање

Једна од основних управљачких структура је условно гранање, које у зависности од потребе, може имати различите форме, а једна од њих је следећа:

<?php

if (условни_израз_1)
{
    блок_наредби_1;
}
elseif (условни_израз_2)
{
    блок_наредби_2;
}

/*... */

elseif (условни_израз_н)
{
    блок_наредби_н;
}
else
{
    последњи_блок_наредби;
}

?>

Када интерпретатор наиђе на овакву структуру, он прво проверава да ли је први први услов (условни_израз_1) испуњен. Ако је први израз тачан, извршиће се први блок наредби. Тај блок може бити група од једне или више наредби, од којих неке такође могу бити сложене управљачке структуре. У колико израз није тачан, испитиваће се истинитост другог условног израза. Затим, у колико је други условни израз тачан, извршиће се други блок наредби. У супротном, наставља се испитивање следећих услова и тако редом, све до последње клаузуле „else“. Овај задњи обухвата све оне случајеве који нису испунили ни један од претходних услова.

У случају да се блок_наредби састоји од само једне наредбе, није неопходна употреба витичастих заграда. Постоје случајеви када није потребно настављати даље гранање, већ се оно завршава са проверавањем првог израза. У том случају неће се писати ни једна од клаузула elseif, а ни else. Најпростији облик условног гранања је следећи:

<?php

if ($godina_rodjenja < 1992) echo "ради се о пунолетној особи";

/*
   или у 2 реда, ради боље прегледности:
*/

if ($godina_rodjenja < 1992)
    echo "ради се о пунолетној особи";

?>

Вишесмерно гранање

У неким ситуацијама је неопходно једну исту променљиву или израз упоредити са различитим вредностима, те у зависности од резултата поређења, извршити различите акције. У тим случајевима је, уместо структуре if, једноставније употребити структуру switch, која има следећи облик:

<?php

switch (израз)
{
    case "вредност_1":
          блок_наредби_1;
    case "вредност_2":
          блок_наредби_2;

    /*... */

    case "вредност_н"
          блок_наредби_н;
    default:
          последњи_блок_наредби;
}

?>

Ова структура се извршава тако што се вредност израза, знаковног (string) или целобројног (integer) типа, редом пореди са различитим случајевима (енгл. case) могућих очекиваних вредности, све док се не наиђе на случај када су те две вредности једнаке. Одатле, па на даље, извршавају се сви блокови наредби, по реду, све до последњег, или се прекида извршавање, у колико постоји наредба за излазак из структуре (енгл. brеаk). Последњи блок наредби је подразумевани случај (енгл. default), који није обавезно навести, односи се на онакве вредности израза, које нису биле обухваћене ни једним од претходних случајева. Блокови наредби могу да садрже групу од једне или више наредби, од којих неке, такође могу бити сложене структуре управљања тока. Типичан пример за употребу структуре switch је следећи:

<?php

switch ($dan)
{
    case 1:
          $rezultat = "понедељак";
          break;
    case 2:
          $rezultat = "уторак";
          break;
    case 3:
          $rezultat = "среда";
          break;
    case 4:
          $rezultat = "четвртак";
          break;
    case 5:
          $rezultat = "петак";
          break;
    default:
          $rezultat = "викенд";
}

?>

Упоређујући исти случај са могућностима структуре if, долази се до закључка, да би у њој иста променљива морала да се више пута исписује поново, као и да би цела структура била би непрегледнија ако би блокови садржали више од једне наредбе:

<?php

if ($dan == 1)
    $rezultat = "понедељак";

elseif ($dan == 2)
    $rezultat = "уторак";

elseif ($dan == 3)
    $rezultat = "среда";

elseif ($dan == 4)
    $rezultat = "четвртак";

elseif ($dan == 5)
    $rezultat = "петак";

else
    $rezultat = "викенд";

?>

Приликом исписивања блокова наредби, посебно треба обратити пажњу на места на којима ће се стајати наредба break, однос прекид извршавања. Јер, у колико не постоји наредба прекида, једном када је резултат поређења да тачну вредност, извршавају се сви следећи блокови наредби, до краја. Тако нпр.:

<?php

switch ($dan)
{
    case 1:
          $rezultat = "понедељак";
    case 2:
          $rezultat = "уторак";
    case 3:
          $rezultat = "среда";
    case 4:
          $rezultat = "четвртак";
    case 5:
          $rezultat = "петак";
    default:
          $rezultat = "викенд";     // вредност променљиве $rezultat ће увек бити „викенд“
}

?>

за било коју вредност променљиве дан, резултат ће увек бити исти.

Такође, блок наредби може да буде и потпуно празан, односно да не садржи ни једну наредбу. Ово напротив, никако не значи да се неће извршити ни један од наредних блокова наредба, баш напротив: <

<?php

switch ($slovo)
{
    case "a":
    case "А":
            $rezultat = "слово а";       // резултат ће бити "слово а",  када је $slovo == "a" и када је $slovo == "A"
            break;
    case "б":
    case "B":
            $rezultat = "слово б"; 
            break;                        // резултат ће бити "слово б",  када је $slovo == "б" и када је $slovo == "Б"
   }

?>

Петље

Петље (енгл. loops) су управљачке структуре за циклично (итеративно) понављање групе наредби, под одређеним условом. Извршавање петљи могуће је прекинути у било ком делу петље употребом наредбе break, док се тренутни прелазак (скок) на следећу итерацију врши наредбом continue. У зависности од начина испитивања услова за извршавање петље и места где је он постављен разликујемо неколико врста петљи.

Петља „докле год“

Петља „докле год“ (енгл. while) је једна од најједноставнијих. Услов за понављање налази се на врху наредбе. Она се представља на следећи начин:

<?php

while (условни_израз)
{
    блок_наредби;
}

?>

Блок наредби се понавља све док је испуњен услов у изразу. Ако је његова вредност нетачна од самог почетка, блок наредби се никад неће извршити. Пример:

<?php

$i = 0;
while ($i < 10)
{
   echo $i; // исписује бројеве од 0 до 9
   $i++;
}

?>

Петља do-while

Специјалан случај петље „докле год“ (енгл. do-while) са условом који се испитује на крају сваке итерације, има следећи облик:

<?php

do
{
    блок_наредби;
}
while (условни_израз)

?>

Блок наредби ће се извршити макар једном, чак и када услов није испуњен ни у првој итерацији. Пример:

<?php

$i = 9;
do
{
    echo $i; // исписује бројеве од 0 до 9 (уназад)
    $i--;
}
while ($i >= 0);

?>

Петља for

Петља for је најсложенији тип петљи. Може да се користи када је број итерација унапред познат. Има следећи облик:

<?php

for (израз1; израз2; израз3)
{
    блок_наредби;
}

?>

Први израз се користи да би се поставила почетна вредност бројача. У другом изразу се поставља услов за понављање, а у трећем се мења вредност бројача. Често се користе код низова и/или када је потребно попунити неку табелу.

Петља „за сваки“

Петља за „сваки елемент“ (енгл. foreach) је варијација петље for, специјално направљена за рад са низовима и другим објектима. Она има два облика:

<?php

foreach (низ as вредност)
{
    блок_наредби;
}

?>

Пролази се кроз цео низ и у свакој итерацији се вредност елемента смешта у променљиву. Ова вредност касније се користи у блоку наредби. Други облик наредбе је следећи:

<?php

foreach (низ as индекс => вредност)
{
    блок_наредби;
}

?>

Где се осим вредности елемента користи и променљива за смештање вредности индекса (кључа) сваког од елемената низа.

Бесконачне петље

У неким случајевима, веома корисне могу бити и бесконачне петље. Оне се безусловно извршавају све док се извршава скирпта. Два најчешћа начина да се направи бесконачна петља су помоћу наредбе while (са параметром 1) или помоћу наредбе for (без параметара):

wile	for
<?php while(1) { print "у петљи while\n" } ?>	<?php for (;;) { print "у петљи for\n" } ?>

Алтернативна синтакса

За управљачке структуре if, while, for, foreach и switch постоји алтернативна синтакса, која омогућава да се за дате структуре уместо витичастих заграда { и }, за означавање почетка користе две тачке (:) , а endif;, endwhile;, endfor;, endforeach;, и endswitch; за завршетака структуре.

Уобичајена синтакса	Алтернативна синтакса
<?php if ($a > 0) { echo "a има позитивну вредност"; } elseif ($a == 0) { echo "a је нула"; } else { echo "а има негативну вредност"; } ?>	<?php if ($a > 0): echo "a има позитивну вредност"; elseif ($a == 0): echo "a је нула"; else: echo "а има негативну вредност"; endif; ?>

Низови

Један од сложенијих типова променљивих су низови (енгл. arrays). Низ је група променљивих референцирана преко истог имена. За разлику од других програмских језика, овде елементи низа могу бити подаци различитог типа. У употреби су две врсте низова:

• нумерички, код којих се користе позитивни цели бројеви за индексирање, почевши од индекса 0

<?php

$a = array(10, 20, 30, 40, 50, 60); // променљива $niz је низ од 6 елемената са индексима од 0 до 5
$zbir = $a[0] + $a[1] + $a[2] + $a[3] + $a[4] + $a[5]; // збир ће имати вредност 210
echo $zbir;
?>

За низове је веома погодно користити петље, да би се прошли сви елементи:

<?php

$a = array(1, "проба", "успешна"); /* низ од 3 елемента, од којих
је сваки другачијег типа: $а[0] = 1; (број)
$a[1] = "проба"; (стринг)
$а[2] = "успешна"; (стринг) */
$suma = ""; // додељује почетну вредност променљивој сума и тип знаковне (string) променљиве
for ($i = 0; $i < sizeof($a); $i++) // петља за обраду елемената низа
{
    $suma .= " " . $a[$i];          // придружује чланове низа у једну променљиву
}
echo $suma; // на крају сума има вредност "1 проба успешна"

?>

<?php

/* Drugi nacin */

$a = array(1, "проба", "успешна"); /* низ од 3 елемента, од којих
је сваки другачијег типа: $а[0] = 1; (број)
$a[1] = "проба"; (стринг)
$а[2] = "успешна"; (стринг) */
for ($i = 0; $i < count($a); $i++) // петља за обраду елемената низа
{
echo" $a[$i]";
} // на крају e вредност "1 проба успешна"
?>

• асоцијативни, који као индексе (кључеве) могу да користе податке знаковног типа (string), осим целобројних (integer)

<?php

$hrana = array("доручак" => "сендвич", "ручак" => "мусака", "вечера" => "јабука"); // дефинише низ $hrana од 3 елемента,
                                                                                   // од којих сваки има свој кључ (знаковни индекс) и вредност
foreach ($hrana as $kljuc => $vrednost)
{
    echo "$kljuc = $vrednost<br />"; /*    на излазу приказује "доручак = сендвич 
                                                                ручак = мусака
                                                                вечера = јабука"      */
}
                 
?>

Оператори за рад са низовима
оператор	назив	употреба	значење
+	унија	$а + $б	враћа низ који се састоји од свих елемента $a и $б
==	једнако	$a == $б	израз је тачан ако су низови $а и $б имају исте парове индекс/вредност
===	идентично	$a === $б	израз је тачан ако су низови $а и $б имају исте парове индекс/вредност, по истом редоследу и типу података
!=	различито	$a != $б	израз је тачан ако је $a различит од $б
<>	различито	$a <> $б	израз је тачан ако је $а различит од $б
!==	није идентично	$a !== $б	израз је тачан ако $а није идентичан $б

Приступ елементима низа је веома једноставан коришћењем угластих заграда []. PHP располаже великим бројем функција за рад са низовима.

Функције низова
назив функције	опис функције
unset()	елиминисање елемената из низа
array_key_exists()	провера за постојање неког индекса (кључа) у низу
array_search()	претрага елемената на основу индекса (кључа)
in_array()	провера за постојање неке вредности у низу
array_keys()	враћа низ кључева наведеног низа
array_values()	враћа низ вредности наведеног низа
array_splice()	брисање елемената низа или њихова замена
count()	враћа број елемената наведеног низа (синоним: sizeof())
sort()	уређује низ по њиховим вредностима у растући редослед
rsort()	уређује низ по у опадајући редослед
asort()	уређује низове по њиховом вредностима у растући абецедни редослед, при чему се врши њихова реиндексација
ksort()	уређује индексе низа по вредностима индекса у растући абецедни редослед
krsort()	уређује индексе низа по вредностима индекса у опадајући редослед
shuffle()	меша елементе низа (насумично уређивање)
array_sum()	сабира вредности свих елемената наведеног низа
array_merge()	спаја два или више низова у један. Важно је водити рачуна о индексима, јер се приликом спајања елиминишу дупликати (важи само за знаковне индексе, док се бројчани аутоматски уређују)
explode()	формира низ из наведене знаковне променљиве (текста). Осим имена низа и променљиве, захтева и знак за раздвајање
implode()	формира текст из наведеног низа. Осим имена низа и променљиве, захтева и знак за раздвајање
array_diff()	упоређује два или више низова, и креира нови на основу елемената по којима се они разликују
array_unique()	уклања дупликате из наведеног низа

Вишедимензионални низови

Вишедимензионални низови (енгл. multidimensional arrays) садрже елементе који могу такође бити низови. Код њих сваки елемент има више од једног индекса. Ако сваки елемент има два индекса, онда се ради о дводимензионалном низу. Пример:

<?php
  $drugovi = array(

      array(1, "Име" => "Драган", "висина" => "195.5", "тежина" => "90.0", "омиљени_спорт" => "кошарка"),
      array(2, "Име" => "Марко", "висина" => "185.5", "тежина" => "80.5”, ”омиљени_спорт" => "пливање"),
      array(3, "Име" => "Саша", "висина" => "180.5", "тежина" => "75.0", "омиљени_спорт" => "фудбал"));

   /* Дефинисан тродимензионални низ са 9 елемената и три кључа: висина, тежина и омиљени спорт.*/
?>

Вишедимензионални низови омогућавају обраду врло сложених структура података, као што су оне који се користе у табелама или базама података. Ови низови такође могу бити нумерички и асоцијативни, те сваки елемент може бити податак различитог типа, што омогућава велику флексибилност и функционалност.

За лакше руковање низовима, на располагању су напредне функције. Функција list() додељује вредности елемената низа, променљивама из листе аргумената

<?php
$picha = array("кафа", "чај", "сок");
list($piche1, $piche2, $piche3) = $piche; // додељује вредности:
                                          // $piche1 = "кафа", $piche2 = "чај" $piche3 = "сок"
list( , , $moje_piche) = $piche; // додељује вредност $moje_piche = ”сок”
?>

Функција print_r() пролази кроз цео низ и разлаже га, прилажући све његове кључеве и придружене вредности. Функција array_walk(), пролази цео низ и враћа вредности свих његових елемената, без кључева. array_flip(), замењује вредности кључева са њиховим вредностима, а у случају асоцијативног низа, истовремено ради и обрнуто: замењује све вредности елемената низа вредностима њихових кључева. За додељивање вредности одређеним елементима низа користи се функција array_fill().

<?php
$a = array ("a" => "јабука", "б" => "банана", "в" => array ("караманка", "калуђерка", "виљамовка"));
print_r ($a);

// резултат штампа у облику
// [а] => јабука
// [б] => банана
// [в] => Array
// (
// [0] => караманка
// [1] => калуђерка
// [2] => виљамовка
// )
array_walk($a);

// враћа резултат
// јабукабананакараманкакалуђеркавиљамовка
?>

Функције

Функције омогућавају извршавање одређеног блока наредби, које се понављају. PHP има доста већ уграђених, али постоји могућност дефинисања сопствених функција. Функција може да се позове из неког другог дела скрипте, прослеђујући јој аргументе, а она затим, када се изврши, може да врати неку вредност. Разлози због којег се користе функције могу бити:

• избегавање поновног писања већ написаног дела кода
• лакше разумевање кода

Функција се декларише помоћу кључне речи function, на следећи начин:

function име_функције(листа_параметара)
{
    блок наредби;
}

Приликом избора имена функције, треба поштовати иста правила, која важе за имена променљивих, с том разликом да се код функција мала и велика слова не разликују и не пише се знак $. Препоручује се да име функције асоцира на акције, које она треба да реализује. Мада је у другим програмским језицима дозвољено, овде се за имена функција не могу искористи имена већ постојећих функција, јер то доводи до грешке у програму, осим ако се истоимена функција не налази у некој спољашњој датотеци. Ипак, чак ни тада се не препоручује, јер може отежати тумачење написаног кода.

У параметрима се наводи низ променљивих, међусобно раздвојених запетом. Функција може имати један или више параметара. Постоје случајеви када неће бити потребан ни један параметар. Међутим чак и у тада је обавезно писање обичних заграда приликом декларисања функције.

function Поздрав()
{
  return "ДОБРО ДОШЛИ";
}

Да би се функција извршила, није довољно да само буде декларисана. Да би се искористила она мора да буде позвана. Није неопходно, али се препоручује, да пре позивања, функција буде већ декларисана. Приликом позивања функције, наводи се листа аргумената.

име_функције(листа_аргумената);

Редослед аргумената, који се наводе у позиву, треба да одговара редоследу параметара у декларацији функције. Као аргументи, могу се навести променљиве, одређене вредности или изрази. Бројне вредности се могу проследити са наводницима или без њих. Није неопходно да број елемената из листа аргумената буде једнак броју елемената из листе параметара. Ако је број аргумената мањи и немају унапред додељену вредност недостајућим променљивама се додељује вредност null (мада долази до грешке, она се неће зауставити извршавање функције). Ако функција враћа неку вредност, она се у позиву може доделити некој променљивој или употребити у неком изразу.

Када се извршавање функције заврши, ток програма се наставља, тачно од места одакле је позвана. Извршавање може да се прекине пошто се прође кроз целу функцију или се ток извршавања може прекинути у било ком делу блока, употребом једне или више наредби за повратак (енгл. return). Претерана употреба наредбе за повратак у оквиру исте функције, може отежати разумевање тока функције. У пракси, најбоље је да постоји један улаз и један излаз из блока наредби. Дозвољена је рекурзија, односно, функција може да позове саму себе. У следећем примеру рачуна се факторијел прослеђеног природног броја:

function факторијел($број)
{
    if ($број < 0)
    {
        return "недозвољена вредност"; 
    }
    elseif (број == 0)
    {
        return 1;
    }
    else
    {
        $помоћна = $број * факторијел($број — 1);    // вредност факторијел се добија рекурзијом
        return $помоћна;
    }
}

Навођењем променљивих у листи аргумената, променљиве се могу проследити.:

• по вредности (енгл. by value), када се унутар функције њихове вредности не мењају
• по адреси, односно референци (енгл. by reference) помоћу симбола &, када је неопходно да се вредност променљиве промени унутар функције. Позив по адреси могућ је једино приликом декларисања функције, никако при њеном позивању, у оквиру аргумената

function додај_један(&$број) // декларација функције са параметром по адреси (&)
{
  $број = $број + 1;                    //увећава вредност за један
}

/* касније се позива функција*/

$број = 1; // променљивој се додељује почетна вредност
додај_један($број); // позива се функција са аргументом (променљива $broj)
echo $број; // добија вредност 2

Параметри могу да имају унапред додељене вредности (енгл. default values). При позивању функције, њих није обавезно навести и само у том случају, унапред додељене вредности имају ефекта. У супротном се користе вредности прослеђене из листе аргумената. У декларацији функције, параметри са унапред одређеним вредностима, наводе се на крају листе.

function додај_сабирак(&$број, $сабирак = 1) // параметар по адреси (&) и параметар са унапред додељеном вредношћу
{
  $број = $број + $сабирак;                 
}

/* касније се позива функција*/

$број = 1; // променљивој се додељује почетна вредност
додај_сабирак($број); // позива се функција са аргументом (променљива $број)
echo $број; // $број добија вредност 2
$збир = 1;
$мој_сабирак = 10;
додај_сабирак($моја_сума, $мој_сабирак); // позива функцију са оба аргумента
echo $збир; // збир је 11

Све променљиве које се користе у оквиру функција, осим оних које се налазе у листи параметара прослеђене по адреси, добијају почетне вредности приликом сваког позивања функције. Те променљиве су локалног карактера, њихове вредности се додељују и расположиве су искључиво у оквиру исте функције. Важи и обрнуто, променљиве дефинисане ван функције, нису расположиве унутар функције, чак ни онда када се ван и у оквиру функције користе истоимене променљиве. На пример, променљива $глоб има додељену вредност 1 на самом почетку програма. Такође, у оквиру функције постоји истоимена локална променљива $глоб. Ове две променљиве неће имати исту вредност. Нпр.

<?php
$глоб = 1; // глобална променљива $глоб

function моја_функција()
{
    echo $глоб ;                       // $глоб је локална променљива и нема додељену вредност*/ 
}

моја_функција(); //позива функцију
?>

Да би променљиве коришћене локално, у оквиру неке функције имале глобални карактер, односно да би њене вредности биле на располагању и ван функције, променљиве је неопходно посебно назначити на један од следећих начина:

• коришћењем кључне речи global:

global $име_променљиве [, ...];

У листи је могуће навести неограничен број променљивих, што би примењено у претходном примеру, за променљиву $глоб би изгледало овако:

<?php
function моја_функција()
{
    global $глоб;
    echo $глоб;                       //променљива $глоб има вредност 1
}
?>

• коришћењем асоцијативног низа $GLOBALS, који је расположив увек и свуда, у било ком окружењу, због чега се назива супер глобалним. Елементе овог низа чине вредности, док индексе низа чине имена расположивих променљивих. У претходном примеру:

<?php
function моја_функција()
{
    global $глобална;
    $GLOBALS["ц"] = $глобална + 1;   // дефинисана је локална променљива $ц
}
?>

Локалне променљиве у оквиру функције губе своје вредности, између различитих позива и поново се додељују приликом сваког извршавања. И ако вредности локалних променљивих не могу бити коришћене ван функције, постоји могућност да се вредности променљивих из претходног позива сачувају, тако што се променљиве унутар функције декларишу као статичке, помоћу кључне речи static и при томе им се може доделити нека почетна вредност.

static $име_променљиве [= вредност];

Почетна вредност ће бити додељена само при првом позиву функције. Пример: функција_увећања ће при сваком позиву увећати вредност променљиве $стат за 6:

<?php
function функција_увећања()
{
   static $стат = 8;
   $стат = $стат + 6;               // 1. позив $стат = 14, 2. позив $стат = 20, 3. позив $стат = 26
}
?>

Управљање датотекама

На располагању је група функција за рад са датотечним системима. Прва функција која омогућава приступ датотеци је функција за отварање датотеке, при чему се ствара објекат типа ресурс, за опис датотеке (енгл. file descriptor), где се смешта информација о датотеци. Отварање се постиже уз помоћ функције fopen:

$фд = fopen( $име_датотеке”, $начин_приступања [, $користити_путању_за_спољашње_датотеке = false [, $ресурс]] );

која има четири могућа параметра, од којих су два обавезна и најчешће се користе:

• име датотеке се претпоставља да се ради о некој доступној веб адреси, која се тражи уз помоћ управљача протокола, односно омотача (енгл. wrapper).
• начин приступања датотеци може да има једну од следећих вредности:

Комбиновани оператори доделе
начин	опис
"r"	отвара за читање, показивач се поставља на почетак датотеке и одатле почиње да пише, без брисања претходног садржаја, ако датотека већ постоји, даје обавештење
"r+"	отвара за читање и писање, остало исто као и претходној опцији
"w"	отвара само за писање, показивач се поставља на почетак датотеке и одатле почиње да пише, бришући сав претходни садржај. Ако датотека не постоји, покушаће да направи нову
"w+"	отвара за читање и писање, остало исто као и у претходној опцији
"a"	отвара само за писање, чува претходни садржај датотеке, поставља показивач на крај датотеке и одатле почиње да пише. Ако датотека не постоји, покушаће да направи нову
"a+"	за читање и писање, остало исто као и опција а
"x"	прави нову датотеку и отвара је само за писање, постављајући показивач на почетак датотеке. Ако датотека већ постоји, даје грешку. Ако датотека не постоји, покушаће да направи нову
"x+"	прави нову датотеку и отвара је за читање и писање. Остало исто као претходна опција
"c"	отвара датотеку само за писање. Ако датотека не постоји, прави нову датотеку, ако постоји прави нову датотеку. Показивач се поставља на почетак датотеке.
"c+"	отвара датотеку за читање и писање. Остало исто као и опција c

• индикатор за коришћење путање спољашњих датотека наведен у опцији include_path у оквиру конфигурацијске датотеке php.ini

Резултат функције може се сместити у променљиву, која садржи показивач на ресурс (означену као $фд у примеру), ако је отварање било успешно или се добија вредност нетачно (false), ако је дошло до грешке приликом отварања.

Једном када се датотека успешно отвори, могуће је читање и писање података из ње.

Писање се се врши уз помоћ функције fwrite:

fwrite ( $фд , $садржај [, $дужина_у_бајтовима] );

којој се прослеђују: показивач на ресурс, садржај који се уписује, као обавезни аргументи, променљива типа string. Могуће је одредити дужину информације за упис, која се изражава бројем бајтова. Резултат ове функције може бити број уписаних бајтова, ако се уписивање успешно извршило или вредност нетачно ако је дошло до грешке приликом уписивања

Читање садржаја, могуће је једино ако је датотека претходно успешно отворена. Може се извршити:

• линију по линију, помоћу функције fgets:

fgets ( resource $фд [, $број_бајтова ] )

где је променљива која садржи показивач на ресурс (означена као $фд у примеру) једини обавезни параметар. Уз њега се може навести променљива у коју ће бити смештен број учитаних бајтова. Учитавање је могуће све док показивач не дође до краја датотеке. Функција враћа учитану линију у колико се успешно извршила, односно вредност нетачно, ако је дошло до грешке. Учитана линија обично се смешта у низ или у знаковну променљиву (string).

• целог садржаја који се смешта у низ помоћу функције fgets
• целог садржаја који се смешта у знаковну (текстуалну) променљиву file_get_contents

Пошто је број отворених ресурса ограничен, када се заврше све потребне акције над датотеком, препоручује се њено затварање, помоћу функције fclose:

fclose ( $фд );

Пример:

<?php

$фд= fopen("datoteka.txt", "r");
if ($фд) {
    while ( !feof($фд)) {
        $линија = fgets($фд);
    }
    if (!feof($фд)) {
        echo "грешкаl\n";
    }
    fclose($фд);
}

?>

Спољашње датотеке

PHP у свом конструктору (језичкој основи) садржи неколико функција које омогућавају употребу спољашњих датотека (енгл. external files) у оквиру скрипте. Различити су разлози због којих се користе спољашње датотеке за смештање: заједничких променљивих, корисничких функција, класа, HTML кода за различите странице / скрипте, података за приступ базама података. Смештањем у спољашње датотеке постиже се лакша прегледност главног кода, уштеда времена, када је потребно да се промени неки податак из датотеке и омогућава се лакша локализација могућих грешака у коду. Користе се четири функције:

include("путања/име_спољашње_датотеке");
require("путања/име_спољашње_датотеке");
include_once("путања/име_спољашње_датотеке");
require_once("путања/име_спољашње_датотеке");

Свакој од њих се прослеђује име датотеке и путања до ње. Навођење путање није обавезно у колико је она наведена у опцији include-path конфигурацијске датотеке php.ini или ако се датотека налази у истом директоријуму као и скрипта која позива спољашњу датотеку. Није обавезна ни употреба заграда, с обзиром да се ради о основним функцијама, најчешће се користе због лакше прегледности. Називи датотека, које се наводе као аргументи ових функција могу да буду произвољни, али се препоручује да њихове екстензије увек буду .php или .inc.php. У супротном, ако корисник покуша сам да отвори неку од оваквих датотека, интерпретатор неће неће препознати као PHP код и приказаће њихов садржај, као да се ради о обичним тексту. Све четири функције веома слично раде: укључују читав садржај наведене датотеке у текућу скрипту. Разлика између функције include и require је у понашању у случају да датотека не постоји или није видљива на наведеној путањи. У том случају функција include само даје упозорење, док је функција require „строжа“ и даје грешку, која зауставља извршавање скрипте. Суфикс „_once“ се односи на функције и класе из спољашње датотеке. Њиме се појашњава да се декларација објеката врши само једном, чиме се спречава вишеструко декларисање, које PHP не дозвољава, пошто иначе, иста спољашња датотека може да се наведе више пута, на различитим местима у програму.

Пример коришћења спољашњих датотека: Датотека за заглавље странице веб (zaglavlje.php) има следећи садржај.

<html>
<head>
<title> Заглавље </title>

</head>
<body>

Датотека за подножје (podnozje.php) странице има следећи садржај:

</body>
</html>

А тело странице (telo.php):

<?php
include("zaglavlje.php");
echo "Ово је садржај тела странице.";
php include("podnozje.php");
?>

На излазу ће се као резултат добити:

<html>
<head>
<title> Заглавље </title>

</head>
<body>
Ово је садржај тела странице.
</body>
</html>

Исто заглавље и подножје, па чак и мени, могу да се искористе за различите странице, чиме се постиже уштеди времена. У колико се користи ћирилице, спољашње датотеке најбоље је да буду сачуване у UTF-8 формату.

Класе и објекти

У објектно-оријентисаном програмирању, за смештање одређене групе функција и променљивих користе се класе. Да би биле доступније у било ком делу истог програма или у неким другим програмима, класе се најчешће исписују у посебним спољашњим датотекама. Класе саме за себе не садрже податке. На основу класа праве се објекти. Класе су модели, апстрактне представе објеката са заједничким особинама и понашањем.

Класа се декларише уз помоћ кључне речи class на следећи начин:

class име_класе {

  //дефиниције атрибута
  [

     public | private | protected | $атрибут [= израз];

     ....
  ]

  //дефиниције метода
  [

     [public | private | protected]  function метода {

       ...
     }

   ...
  ]
}

Приликом избора имена класа важе иста правила, као и за имена функција и променљивих. Осим тога, интерпретатор не прави разлику између малих и великих слова, али је обичај да у именима класа почетак речи буде велико слово, а да остала слова буду мала, како би се разликовале од осталих идентификатора. Својства, односно атрибути (енгл. attributes), особине или карактеристике су скуп променљивих, од којих неке могу да имају почетну вредност. Вредност се дефинише преко једноставних израза, који не могу да садрже друге променљиве, нити функције. Акције или понашање класе дефинише се преко метода, које заправо имају улогу функција у структурном програмирању, с том разликом да је дозвољено да метода неке друге класе или спољашња корисничка функција носе исто име. Гледајући дефиницију класе, лако се може закључити да су то заправо колекције променљивих и функција, преко којих се дефинишу њена својства и понашање. Како својства, тако и методе могу имати различиту видљивост у односу на своје окружење. Ово се декларише преко кључних речи:

• public — атрибути и методе су јавни, односно потпуно су доступни ван постојеће класе
• private — атрибути и методе су доступни једино унутар класе
• protected — атрибути и методе су доступни унутар саме класе или унутар класа изведених (енгл. extended) од ње.

За методе важи правило да ако се не наведе ни једна од од ове три кључне речи, она се сматра јавном, док је код променљивих обавезно навести једну од три могућности за њихову доступност. Ово правило је уведено од пете верзије (PHP.5), док су у претходној верзији све методе и сви атрибути били јавни. Тада је за атрибуте било обавезно употребити кључну реч var, која има исто значење као и public, док за методе међутим, није било могућности избора доступности, све су биле јавне.

Да би се створио нови објекат потребно је да се направи нова инстанца (енгл. instance), односно примерак класе, помоћу кључне речи new, при чему објекат добија структуру класе и осим тога, садржи податке.

име_објекта = new име_класе(листа_аргумената);

За одређени објекат (инстанцу класе), да би се приступило неком атрибуту или методи:

• Искључиво унутар саме класе, користи се кључна реч $this, променљиве која означава сопствени објекат, уз оператор ->:

$this->име_атрибута;

$this->име_методе();

• Ван класе, једном када је направљен нови објекат и пошто се извршила метода конструктора, помоћу имена конкретног објекта и оператора ->:

име_објекта->име_атрибута;

име_објекта->име_методе();

Треба имати на уму да се $this не може употребити ван класе, јер иначе даје грешку.

Специјалне методе класе

У PHP постоји више уграђених специјалних метода, које имају одређену функцију у класи. Једна од специјалних метода може да носи исто име као и сама класа. У том случају, ради се о методи конструктору. Приликом креирања (инстанцирања) новог објекта, то је прва метода, која се аутоматски позива. Уз помоћ ње се додељују одређене почетне вредности променљивих (атрибута) у оквиру класе, а могуће је извршити и одређене функције. Други начин за означавање конструктора је помоћу методе __construct(), која носи две доње црте испред имена. Заправо, да би идентификовао методу конструктора, интерпретатор прво тражи функцију која носи назив __construct(), па ако је не пронађе, онда тражи методу која носи име класе, јер у претходним верзијама PHP није постојала метода __construct().

Мада није обавезно, осим конструктора, свака класа може да садржи и уништавача __destruct(), функцију без параметара, која се извршава аутоматски, пошто се елиминише и последњи објекат (инстанца) дотичне класе. Ову методу није неопходно посебно наводити, јер је већ аутоматски уграђена, али ако се наведе, у оквиру класе могуће је искористити податке из објекта (да се упишу у базу података нпр.), управо пре него што се објекат уништи. Метода __destruct() ван класе позива се помоћу наредбе:

unset($име_објекта);

Понекад постоји потреба да се приликом позивања неког објекта, уместо целе структуре класе добија само једна знаковна ниска (литерал), за шта се користи метода __toString. Помоћу ове методе, враћа се у облику текста, она информација о класи, за коју се сматра да је сходна.

За копирање објеката користи се метода __clone. Она аутоматски копира све податке из једног објеката у други. С обзиром да аутоматско копирање није увек жељено понашање приликом копирања објекта, постоји могућност да се у оквиру саме класе прецизно дефинишу само подаци које треба копирати, као и начин на који ће се то извршити. Ова метода позива се помоћу кључне речи clone:

$објекат = new име_класе();

$клонирани_објекат = clone $објекат;

У пракси се не препоручује да све методе и атрибути једне класе буду јавни. Да би се добиле и мењале вредности одређених атрибута, обично се користе посебне јавне методе за приступ, док се сами атрибути декларишу као приватни. Тако нпр. као у класи „Корисник“ са атрибутима: број, име и презиме, декларише се 6 функција за приступ:

class Корисник
{
  private $broj;
  private $ime;
  private $prezime;
  
  function getBroj(){
    return $this->broj;
  }
  function setBroj($broj){
    $this->broj = $broj;
  }
  function getIme(){
    return $this->ime;
  }
  function setIme($ime){
    $this->ime = $ime;
  }
  function getPrezime(){
    return $this->prezime;
  }
 function setPrezime($prezime){
    $this->prezime = $prezime;
 }
}

Међутим, класа може да има велики број атрибута и метода, па писање оваквих функција за приступ може бити веома компликовано. Када се не ради о недоступним (недекларисаним или приватним) атрибутима или методама, који се неће позивати по референци (адреси) и нису статички, могуће је креирати атрибуте и методе, на динамички начин коришћењем специјалних метода (енгл. magic methods), које се извршавају аутоматски сваки пут:

• __set() када се уписују подаци у објекат
• __get() када се учитавају подаци из објекта

Начин на који ће се извршити учитавање или уписивање података, дефинише се у оквиру класе. Тако у претходном примеру, уместо метода са префиксом get и set, могуће је употребити само две функције, које важе за било који атрибут:

public function __get($atribut) {
    switch ($atribut) {
      case "":
          return "";
      default:
        return $this->$atrb;
    }
}

public function __set($atribut, $vrednost) {
    switch ($atribut) {
      case "":
          return "";
      default:
        $this->$atribut = $vrednost;
    }
}

За испитивање да ли неки од овакво дефинисаних атрибута има вредност, користи се функција empty() при чему се у класи аутоматски извршава метод __issset(), а при позивању невидљивих метода, извршава се метод „__call“.

<?php
class Тест{
  protected елементи = array();
  public function __get($парам){
     if array_key_exists($парам, $this->елементи){
       return ($this->елементи[$парам]);
     }
     else {
        return ("не постоји атрибут");
     }
  }
  public function __set($кључ, $вредност)
  {
    $this->елементи[$кључ] = $вредност;
  }
  public function __isset($парам)
  {
     return (isset($this->елемент[$парам]));
  }
}

$објекат = new Тест();
print $објекат->брзина; // ”не постоји елемент”, јер још увек није постављена вредност
$објекат->брзина = ”55”;
if (emtpy($objekat->брзина))
{
  echo "атрибут брзина је постављен”;
}
$објекат->брзина = null;
if (emtpy($objekat->брзина))
{
  echo "Такође позива методу __isset”; // мада је вредност атрибута празна (null) атрибут је дефинисан
}

?>

Наслеђивање

Различити начини једноструког наслеђивања класа

Наслеђивање (енгл. Inheritance) је једна од најкориснијих алатки у објектно-оријентисаном програмирању, која омогућава да корисник дефинише основну класу обично са једноставнијим или заједничким атрибутима и методама, и на основу ње изведе нове класе, које садрже извесне специфичности у односу на основну класу. Каже се да ако је Б класа исто што и А, а не важи обрнуто, онда је А наткласа или основна класа, а Б је изведена класа. Основна класа се назива родитељ или наткласа (енгл. superclass), а све класе изведене од ње су њена деца или поткласе (енгл. subclass). Деца наслеђују све родитељске атрибуте и методе, декларисане као јавне (public) или као заштићене (protected), неке од њих могу да се измене (енгл. overload) и такође, свако дете може да надогради класу родитеља, новим атрибутима и методама. Специјално у случају да су неки метод или цела родитељска класа, декларисани као завршни или финални (енгл. final), они неће моћи да буду измењен у изведеној класи. Док свака класа родитељ може имати више изведених класа, свака изведена класа може имати само једног родитеља, односно, наслеђивање је једноструко. За разлику од других програмских језика, попут C++ што их чини или врло сложеним или мање ефикасним, овде вишеструко наслеђивање није подржано.

Декларисање изведене класе врши се на основу родитељске класе уз помоћ кључне речи extends,

class ИмеКласеДетета extends ИмеКласеРодитеља {

  // тело класе детета
}

због чега је неопходно да родитељска класа буде претходно декларисана, пре било које изведене класе и њен код мора да буде доступан изведеној класи. Родитељска класа најчешће се пише у посебној датотеци, што је потребно навести на самом почетку, помоћу наредбе за коришћење спољашњих датотека пре декларисања изведене класе.

Осим тога, у изведеној класи наводе се само нови или они атрибути и методе из родитељске класе, које је потребно изменити. Истоимене методе наведене у изведеној класи неће се извршити у родитељској класи, осим ако се у изведеној класи специјално не наведе позив на родитељску методу. За позивање метода родитељске класе (укључујући и методу конструктор) из изведене класе, користи се кључна реч parent, уместо имена родитељске класе, а иза кључне речи следе две двотачке и име методе, коју треба извршити.

class Родитељ {
    function пример() {
        echo "метода — пример у родитељској класи.<br />\n";
    }
}
class Дете extends Родитељ {
    function пример() {
        echo "Измењена метода — пример.<br />\n";
        parent::пример();   //позива истоимену родитељску методу
    }
}

У следећем примеру налази се основна класа Запослени, из које се изводи посебна класа Продавац, као специфичан случај Запослених, код којих у се у обрачуну плате узима у обзир и провизија од количине продатих производа. Касније, у главном делу скрипте, користе се обе класе:

Класе родитељ и дете

<?php
class Запослени
{
   private $име;
   protected $плата;
   private $датум_запослења;
   public function __construct($име, $плата, $датум)
   {
     $this->име = $име;
     $this->плата = $плата;
     $this->датум_запослења = $датум;
   }
   public function рачунаПлату()
   {
      return $this->плата;
   }
}
class Продавац extends Запослени
{
   private $продато;
   private $провизија;
   public function __construct($име, $плата, $датум, $провизија)
   {
     parent::__construct($име, $плата, $датум);
     $this->продато = 0;
     $this->провизија = $провизија;
   }
   public function продаја($количина)
   {
     $this->продато = $this->продато + $количина;
   }
   public function рачунаПлату()
   {
     return ($this->плата + ($this->продато * $this->провизија / 100));
   }
}
 $марко = new Запослени("Марко Краљевић", 56000, "10/04/2010");
 $ана = new Продавац("Ана Бркић", 40000, "21/02/2012", 50);
 $маркова_плата = $марко->рачунаПлату();
 $ана->продаја (1000);
 $анина_плата = $ана->рачунаПлату();
 
 echo "<p>Маркова плата је $маркова_плата</p>"; //Маркова плата је 56000
 echo "<p>Анина плата је $анина_плата</p>";     //Анина плата је 40500
?>

Да би се утврдило да ли је неки објекат примерак одређене класе, користи се оператор instanceof, који примењен над неким објектом у изразу, враћа вредности тачно или нетачно. За примерке наслеђених класа, резултат операције у односу на родитељску класу, такође ће се добити тачна вредност:

<?php
class КласаРодитељ
{
}

class КласаДете extends КласаРодитељ
{
}
$објекат = new КласаДете;
var_dump($a instanceof КласаДете); // тачно boolean(true)
var_dump($a instanceof КласаРодитељ); // тачно boolean(true)
?>

Апстрактне класе

Апстрактне класе (енгл. abstract classes) уведене су од 5. верзије PHP, за потребе објектно-оријентисаног програмирања и представљају шаблоне или моделе структура за класе наследнике изведене из ње. Апстрактна је свака она класа која садржи најмање једну апстрактну методу и обрнуто, у свакој апстрактној класи мора да постоји најмање једна апстрактна метода. Ни једна апстрактна метода не сме бити декларисана као приватна, јер треба да буде наслеђена, нити може бити финална, јер треба да буде измењена у наслеђеној класи. Апстрактне методе су оне које садрже искључиво декларацију методе, без писања кода који описују како ће се метода извршити. По апстрактном моделу није могуће створити ни један објекат, сваки покушај да се тако нешто учини даје грешку. Апстрактне класе декларишу се помоћу кључне речи abstract.

abrstract class АпстрактнаКласа{

   abstract protected function обавезнаМетода1();

   abstract protected function обавезнаМетода2();
...
}

Све методе декларисане као апстрактне у шаблону, обавезно морају да буду дефинисане и у изведеним класама и њихова видљивост, односно домен, мора бити исти или још рестриктивнији, него у основној класи. Нпр. ако је нека метода у апстрактној класи дефинисана као заштићена (protected), онда иста метода мора да постоји и у изведеној класи и може бити декларисана или као заштићена или као јавна, али никако не може бити приватна.

Интерфејси

Интерфејси (енгл. interfaces) су својеврсна скица или шаблон састављен од јавних апстрактних метода, при чему се методе у интерфејсу декларишу, не садрже никакве детаље око њиховог извршавања, наводе се само имена метода и параметри. Исто као и код апстрактних класа, од интерфејса се не могу стварати објекти. Интерфејси служе искључиво за дефинисање оне групе метода које треба да постоје у свакој класи у којима се интерфејс примењује, односно имплементира (енгл. implement). За декларацију интерфејса користи се кључна реч interface. Осим метода, интерфејси могу да садрже и константе. Исто као и класе, интерфејси могу да наслеђују један другог.

interface име_интерфејса()
{
  //дефиниције метода

  [public] function метода();

  ...
}

Све методе интерфејса су јавне, због чега није неопходно наводити кључну реч public. Да би се интерфејси применили у класама користи се кључна реч implements, иза које следи листа интерфејса.

class име_класе implements име_интерфјеса1, име_интерфејса2 ...{
...
}

Класа може да наследи само једну класу и може да примени више различитих интерфејса, при чему у тим интерфејсима не смеју да постоје истоимене методе. Осим тога, класа мора да садржи све методе декларисане у интерфејсима. Ако се не дефинишу експлицитно у класи, методе ће се применити имплицитно, али онда класа која их примењује мора да буде апстрактна, јер у супротном долази до грешке. Осим тога, приликом употребе интерфејса у класама, битно је којим ће се редом свака од метода извршавати. Интерфејси могу да се употребе у класама онолико путе колико је то потребно.

Док су интерфејси стандардне структуре у неким другим језицима, као нпр. у Јави, они се у PHP ређе употребљавају.

Именски простор

Именски простор је уведен од верзије 5.3 и превасходно је замишљен ради решавања конфликта око истоимених метода и функција, како би могле да се користе у оквиру истог пројекта. Ово је посебно погодно у случају да се ради о комплексним пројектима, који су распоређени по различитим датотекама и када у развоју апликације учествује група програмера. За декларисање именског простора користи се кључна реч namespace и при чему морају да се испуне следећи услови:

• пре прве декларације именског простора не сме да постоји никакав други PHP код (ни HTML код, осим ознаке ни белине), осим декларација уз помоћ кључне речи declare. Односно, испред декларације именског простора могу да стоје само ознака <HTML>, ознака за PHP код <?php, као декларације за блокове
• именски простор је јединствен и за његову декларацију не могу се употребити кључне речи. За именске просторе не може се користити ни реч php (или PHP), нити било какве сложенице на бази ње (као нпр. „PHP\Class“)
• пре прве примене именског простора, неопходно је да сав остали код буде дефинисан у том истом именском простору, што се обично чини употребом витичастих заграда {}

Дозвољено је користити више именских простора у оквиру истог програма, чак и исте датотеке, са могућношћу располагања на глобалном нивоу.

Изузеци

Изузеци (енгл. exceptions) су реакције у сопственом коду на одређене догађаје, за време извршавања програма, што захтева посебан блок наредби, како би такве ситуације биле третиране на одговарајући начин. Конкретно за PHP, од верзије #-.7BPHP.7D- 5.0. у ту сврху се користе објекти из класе Exception или било које друге класе изведене из ње. Структура основне класе има следећи изглед:

Exception {
/* Атрибути класе Exception*/
protected string $message ; // порука изузетка

protected int $code ; // идентификациони број изузетка

protected string $file ; // датотека у којој је побуђен изузетак

protected int $line ; // линија у којој је искочио изузетак

/* Методе класе Exception */

public __construct ([ string $message = "" [, int $code = 0 [, Exception $previous = NULL ]]] )

final public string getMessage ( void ) // Враћа поруку о изузетку, као знаковну променљиву (String)

final public Exception getPrevious ( void ) // враћа претходни објекат изузетка (класе Exception)

final public mixed getCode ( void ) // враћа број изузетка

final public string getFile ( void ) //враћа датотеку у којој је искочио изузетак

final public int getLine ( void ) //враћа број линије у којој је искочио изузетак

final public array getTrace ( void ) // враћа низ са стеком извршавања изузетка

final public string getTraceAsString ( void ) // враћа знаковну променљиву уместо низа

public string __toString ( void ) // изузетак представљен помоћу знаковне променљиве

final private void __clone ( void ) // није дозвољено клонирање изузетака, метода враћа грешку
}

Да би се на прави начин третирао изузетак, објекат из класе изузетака треба да располаже: поруком о разлогу избацивања Message, идентификационим бројем или кодом (енгл. code) изузетка, бројем линијског кода (енгл. line) и именом датотеке (енгл. file) у којој је изузетак избачен.

Објекти, као примерци изузетака су веома корисни за испитивање исправности програма. Помоћу њих се постиже да све остане под контролом, тако што се програм прилагоди насталој ситуацији и настави даље извршавање, чак и у случају да се деси нешто „лоше“ у програму, односно или дође до неке грешке.

Контрола могућих грешака врши се помоћу структура формираних од кључних речи try{} и catch{}, где свака од њих обухвата одређени блок наредби, уписаних између витичастих заграда. Уз сваки блок try треба поставити најмање један, а може и више блокова catch. Више блокова catch пише када постоје изузеци из различитих класа изведених из класеException. Структура try — catch могла би се превести на обичан језик следећом реченицом: „пробај блок try и ако се деси неки изузетак, пређи на блок catch. У блоку catch дефинише се шта је тачно потребно урадити у колико дође до изузетка. Изузетак може бити: побуђен (енгл. rаised), односно избачен (енгл. throwen), или ухваћен (енгл. catched). Ово се постиже уз помоћ кључне речи throw. Њоме се креира конкретан објекат из класе Exception. Обично се поставља на почетку блока или функције try, a може се употребити и у блоку catch, једном када је изузетак ухваћен.

Постављањем кључне речи throw на почетку блока, спречава се даље извршавање наредби у оквиру тог блока. Следећи корак у извршавању је тражење блока catch и испитивање услова да ли изузетак припада класи, односно типу који је могуће контролисати у оквиру тог блока.

<?php
class ДиректоријумИзузетак extends Exception {}
class ДатотекаИзузетак extends Exception {}
function провериДиректоријум($директоријум)
{
   if (!is_dir($директоријум))
      throw new ДиректоријумИзузетак("Погрешан директоријум:" . $директоријум);
}
function провериДатотеку($датотека)
{
       if(!file_exists($датотека))
         throw new ДатотекаИзузетак("Не постоји датотека:" . $датотека);
 
}
function отвориДатотеку($директоријум, $датотека)
{
   провериДиректоријум($директоријум);
   провериДатотеку($директоријум . $датотека);
   throw new Exception("Било која грешка");
   $фд = fopen($директоријум . $датотека, "a+");
   return $фд;
}

$директоријум = "C:/proba/";
$датотека = "text.txt";
try
{
   $фд = отвориДатотеку($директоријум, $датотека);
   fclose($фд);
}
catch (ДиректоријумИзузетак $e) //ако не постоји директоријум
{
  echo $e->getMessage();         //штампа текст "Погрешан директоријум:C:/proba/"
}
catch (ДатотекаИзузетак $e) // ако не постоји датотека
{
  echo $e->getMessage();         // штампа текст "Не постоји датотека:C:/proba/text.txt"
}
catch (Exception $e)
{
  echo $e->getMessage();
}
?>

Када се користе различите класе изузетака, веома је битан редослед којим се хватају изузеци. Прво се наводе конкретнији случајеви помоћу изведених класа (ДиректоријумИзузетак и ДатотекаИзузетак) , а касније иду генералнији случајеви користећи класу базу — Exception.

Ако се услов за хватање не испуни, изузетак бива избачен, односно прослеђен на више родитељске блокове, где се очекује да постоји контрола. У случају да грешка не може да се ухвати ни на једном нивоу, долази до грешке (енгл. fatal error), која зауставља извршавање скрипте. Ради избегавања неконтролисаних изузетака, може да се дефинише управљање изузецима уз помоћ функције set_exception_handler. или управљање грешкама set_error_handler

Подаци добијени уз помоћ функција за руковање изузецима, односно грешкама, могу се на контролисан начин приказати кориснику на екрану, регистровати у датотеци или послати преко електронске поште, помоћу функције error_log или помоћу истоимене опције у конфигурацијској датотеци php.in Врсте грешака које ће се на овај начин контролисати зависе од параметра error_reporting, док се приказивање на екрану може подесити помоћу опције display_errors, што је корисно приликом проба и депурације кода, али се у крајњој верзији за клијената радије препоручује опција log_errors, навођење путање регистра у конфигурацијској датотеци php.ini.

Управљање грешкама уз помоћ изузетака доста је јасније и лакше од класичног начина, међутим, као термин у PHP-у, он је још увек недовољно развијен, јер изузеци нне искачу аутоматски, не генерише их интерпретатор, за разлику од неких других објектно-оријентисаних језика, који у ту сврху пружају далеко веће могућности.

Кључне речи

Кључне речи (енгл. keywords) су резервисане речи. Имају специјално значење и на располагању су у било ком делу програма (скрипте). Оне чине основу PHP језика. Употреба њихових имена за дефинисање сопствених променљивих може довести до конфузије. Ипак, могу слободно да се користе као имена корисничких константи, функција, метода, класа и објеката. Следи табела основних кључних речи:

Кључне речи
кључна реч	опис
__halt_compiler()	Зауставља извршење компајлера
abstract	дефинише апстрактне класе и методе
and	логички оператор нижег приоритета
array()	креира низ
as	користи се у петљи foreach за нумеричке или асоцијативне низове
break	прекида извршавање актуелне структуре у петљама for, foreach, while, do-while или switch
callable
case	користи се као услов у структури switch
catch	користи се као клаузула блока try
class	дефинише класу
clone	креира копију објекта
const	дефинише константу на локалном нивоу
constаnt()	враћа вредност претходно дефинисане константе
continue	наставља извршавање на крај петље
declare
default	подразумевана клаузула блока структури switch
define	дефинише константе на глобалном нивоу
defined()	проверава да ли је дефинисана константа
die()	исто што и exit()
do	клаузула петље do-while
echo	шаље променљиве на стандардни излаз
else	клаузула контролне структуре if
elseif	клаузула контролне структуре if
empty()	утврђује да је променљива без додељене вредности (null), обрнуто од isset()
enddeclare
endfor	завршетак петље for у другој синтакси
endforeach	завршетак петље foreach у другој синтакси
endif	завршетак контролне структуре if у другој синтакси
endswitch	завршетак контролне структуре switch у другој синтакси
endwhile	завршетак петље while у другој синтакси
eval()	процењује да ли променљива знаковног типа представља PHP кода
exit()	зауставља извршавање скрипте, исто што и die()
extends	дефинише родитељску класу актуелној класи
final	у декларацији да означи као класу или методу која не може да се наследи
for	петља
foreach	петља
function	дефинише корисничку функцију
global	глобална променљива
goto	скаче на други део програма, циљна тачка је наведена лабелом праћеном двотачком
if	контролна структура
implements	употреба интерфејса у класи
include	коришћење спољашње датотеке
include_once	коришћење спољашње датотеке са једном декларацијом
instanceof	оператор који утврђује да ли је неки објекат примерак одређене класе или наслеђене класе
insteadof
interface	декларише интерфејс
isset()	проверава да ли променљива има додељену вредност, супротно од isempty()
list()	додељује вредности низа променљивама из листе аргумената
namespace	декларише именски простор
new	креира нови објекат према моделу класе
or	клаузула наредбе if
print	шаље променљиву на излаз
private	декларише атрибут или методу доступну унутар једне класе
protected	декларише атрибут или методу доступну унутар једне класе и свих класа изведених од ње
public	декларише јавни атрибут или класу
require	коришћење спољашње датотеке
require_once	коришћење спољашње датотеке са једном декларацијом
return	повратак из корисничке функције
static	декларише променљиве и функције које не мењају вредност између позива
switch	структура за вишесмерно гранање
throw	испаљује изузетак
trait
try	блок кода за хватање изузетака
unset()	поништава претходно додељену вредност променљивој или класи
use	коришћене именског простора
var	декларише јавни атрибут (променљиву) класе
while	петља
xor	логички оператор нижег приоритета

Рад са формама

Форма, формулар или образац (енгл. form) је један од значајних елемената динамичког аспекта већине интернет апликација, у којима приказ веб-странице зависи од корисничких акција. Међутим, форма је заправо део HTML структуре, за груписање различитих елемената, чија је функција прикупљање података од корисника. У зависности од акције корисника, добијена информација се може проверити код корисника, затим се може послати као захтев серверу, на поновну проверу и обраду података, а у зависности од потребе на крају се може послати и повратна информација. Пример:

Пример HTML странице са уграђеним формуларом

<!DOCTYPE html>
<html lang="mul" dir="ltr">
    <head>
        <meta charset="utf-8" />
        <title>Википедија</title>
    </head>
    <body>
        <div style="margin-left: 80px;">
            <img src="http://upload.wikimedia.org/wikipedia/sr/b/bc/Wiki.png" alt="Википедија" />
        </div>
        <div class="central-featured-lang lang1" lang="sr">
            <a href="http://sr.wikipedia.org/" title = "Српски — Википедија — слободна енциклопедија" 
                 style="margin-left: 115px;">
                <strong>Српски</strong>

                <em style="margin-left: 60px;">Слободна енциклопедија</em>

                <small style="margin-left: 95px;">170 000+ чланака</small>
            </a>
        </div>
        <form action="http://www.wikipedia.org/search-redirect.php">
            <input type="hidden" name="family" value="wikipedia" />
            <input id="searchInput" name="search" type="search" size="20" 
                       autofocus="autofocus" accesskey="F" />
            <select id="searchLanguage" name="language">
                <option value="sr" lang="sr" selected="selected">Српски / Srpski</option>
                <option value="es" lang="es">Español</option>
                <option value="ru" lang="ru">Русский</option>
                <option value="en" lang="en">English</option>
            </select>
            <input class="formBtn" type="submit" value="  ⇒  " name="go" style="margin-top: 20px;" />
            <input type="hidden" value="Go" name="go" />
        </form>
    </body>
</html>

Форме су заправо невидљиви контејнери постављени између ознака за почетак <form> и крај </form>. Битни атрибути ове етикете су:

• action — која садржи веб адресу на серверу на којој ће се извршити обрада информације добијене из формулара
• method — којом се дефинише метода за преношење података из формулара. Постоје две методе: GET и POST

Метода GET се користи ако се не наведе ни једна метода. Њоме се информација унета у формулар надовезује на веб адресу из атрибута action и има следећи облик:

http://веб_адреса?име_поља1=вредност1&име_поља2=вредност2 ...

при чему треба водити рачуна да постоје ограничења за укупну дужину веб адресе. Осим тога, ова метода није сигурна и не може се користити за слање лозинки и осталих личних података корисника.

Метода POST преноси информацију на нешто сигурнији начин, нема ограничења у величини информације, а шаље се као део документа у облику улазног тока података, формирајући парове: име_поља1=вредност1&име_поља2=вредност2.

Техничке могућности

Развојни тим PHP-а се састоји од неколико десетина програмера, и још неколико десетина радника који раде на другим пројектима везаним за PHP, као што је PEAR и документација PHP-а. Поред овога, PHP-у су добровољно доприносили многи програмери широм света. Брз развој је проузроковао да PHP поседује велики број библиотека и функција, али и проблем неконзистентности у именовању уграђених функција.

Следи детаљан списак могућности које PHP нуди кроз своје библиотеке и додатке:

• Комуникација са базама података; подржане базе:
  • MySQL
  • mSQL
  • PostgreSQL
  • SQLite
  • Sybase
  • ODBC
  • Oracle
  • Microsoft SQL
  • DB++
  • dBase
• Рад са XML документима; независне библиотеке:
  • XML DOM
  • XMLReader и XMLWriter
  • SimpleXML
• Рад са текстовима у страним језицима
  • Библиотека Gettext
  • Функције за рад са нискама вишебајтних карактера
• Рад са великим бројевима; библиотека GMP (Енг. GNU Multiple Precision)
• Рад са датумима и календаром (подржава грегоријански и јулијански календар)
• Креирање PDF докумената; независне библиотеке:
  • Haru PDF
  • PDFLib
• Компресија; подржани алгоритми:
  • Rar
  • ZIP
  • Bzip2
  • Zlib
• Криптовање (функција mcrypt); подржани алгоритми:
  • DES
  • TripleDES
  • Blowfish
  • 3-WAY
  • SAFER-SK64
  • SAFER-SK128
  • TWOFISH
  • TEA
  • RC2
  • GOST
  • RC6
  • IDEA
• Рад са сликама
  • Уређивање слика (библиотека GD)
  • Читање мета-информација о сликама (Библиотека Exif)
• Рад са датотечним системом (директоријумима и датотекама)
• Кеширање стандардног излаза
• Конзолна графика (библиотека NCurses)
• Рад са штампачем
• Мрежна комуникација преко сокета
• Интеграција PHP-Јава
• Директан приступ сервису електронске поште
• Рад са стандардним протоколима:
  • FTP
  • HTTP
• Извршавање екстерних извршних датотека
• Рад са COM и .NET објектима за Windows

Компатибилност

PHP је подржан у већини популарних оперативних система, укључујући Јуникс, Линукс, Microsoft Windows и Мек ОС.

Доступност и лиценца

PHP се може бесплатно преузети широм Интернета и на званичном сајту PHP-а, а лиценциран је PHP лиценцом, која предвиђа:

Производи који се добијају из овог софтвера не смеју се назвати "PHP", нити се сме "PHP" појављивати у њиховом имену, без претходне писмене дозволе од [email protected]. Можете указати на то да ваш софтвер функционише заједно са PHP-ом говорећи "Foo за PHP" умјесто да га зовете "PHP Foo" или "phpfoo".

Ово ограничење употребе "PHP"-а чини лиценцу PHP неспојивом с Општом јавном лиценцом, док Зенд лиценца није компатибилна због рекламне клаузуле сличне оној из оригиналне BSD лиценце.

Литература

• Trachtenberg, Adam (2004). Upgrading to PHP 5. "O'Reilly Media, Inc.". ISBN 978-0-596-00636-5. 
• Gogala, Mladen; MacIntyre, Peter; Danchilla, Brian (2011). Pro PHP Programming. Apress. ISBN 978-1-4302-3560-6. 
• Heurtel, Olivier (2011). PHP 5.3: Desarrollar un sitio Web dinámico e interactivo. Ediciones ENI. стр. 147. ISBN 978-2-7460-6666-3. 
• Davis, Michele E.; Phillips, Jon A. (2007). Learning PHP & MySQL: Step-by-Step Guide to Creating Database-Driven Web Sites. "O'Reilly Media, Inc.". ISBN 978-0-596-55165-0. 
• MacIntyre, Peter (2010). PHP: The Good Parts. "O'Reilly Media, Inc.". стр. 120—. ISBN 978-1-4493-9074-7. 
• Hudson, Paul (2005). PHP in a Nutshell. "O'Reilly Media, Inc.". ISBN 978-1-4493-7912-4. 
• Lurig, Mario (2008). PHP Reference: Beginner to Intermediate PHP5. Mario Lurig. ISBN 978-1-4357-1590-5. 
• Ullman, Larry (2009). PHP for the Web: Visual QuickStart Guide. Peachpit Press. ISBN 978-0-321-61744-6. 
• Welling, Luke; Thomson, Laura (2003). PHP and MySQL Web Development. Sams Publishing. ISBN 978-0-672-32525-0. 
• Cobo, Ángel (2005). PHP y MySQL: Tecnología para el desarrollo de aplicaciones web. Ediciones Díaz de Santos. ISBN 978-84-7978-706-6. 
• Atkinson, Leon; Suraski, Zeev (2004). Core PHP Programming. Prentice Hall Professional. ISBN 978-0-13-046346-3. 

Додатна литература

• Ford, Paul (11. 6. 2015). „What is Code?”. Bloomberg Businessweek. „What’s the Absolute Minimum I Must Know About PHP?” 

Спољашње везе

• Званични веб-сајт
• [https://web.archive.org/web/20120508132623/http://www.php.net/manual/sr/index.php Архивирано на сајту Wayback Machine (8. мај 2012) Пуна документација](језик: српски)(језик: енглески)
• PHP source code repository на веб-сајту GitHub
• PHP туторијали
• PHP на сајту Twitter