Programmeerimine PHP (0)

 
 
 
 
 
 
 
 
 
Programmeerimine keeles PHP 
 
 
 
Andrei Porõvkin 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Tartu Ülikool (2009) 
 
 
1
1.1 Üldinfo
Alguses oli interneti lehed omavahel seotud staatiliste html dokumentide süsteemina, aga selleks, et mingis dokumendis muutusi teha
oli vaja lehti failisüsteemis käsitsi muuta. Kahjuks selline staatiline mudel ei jõua kiirelt muutuva kaasaegse maailma progressile järgi.
Seega võeti kasutusele dünaamiline mudel. Dünaamilise mudeli korral ei hoita serveris staatilisi html lehte vaid neid genereeritakse
selleks spetsiaalselt välja töötatud programmidega, mis  serveril  töötavad.
Antud kursuse jooksul tutvume  klient - server  arhitektuuriga, installeerime enda  arvutisse   veebiserveri  ja php interpretaatori ning saame
baasteadmisi serveripoolsest keelest PHP. Kursuse teemad on pühendatud ainult PHP keelele (väljarvatud seitsmes teema), aga see ei
tähenda, et sellest  piisab  suure ja eduka veebilehe loomiseks. Mahuka infosüsteemi ei saa ette kujutada ilma andmebaasideta,  cache -
süsteemideta, mallimootoriteta, jne.
See  baaskursus  on mõeldud eelkõige selleks, et õpilasel tekiks huvi PHP vastu ja ta hakkaks ise edaspidi rohkem õppima ja katsetama.
Kursuse viimastes peatükkides  vaatleme  ka  MySQL  admebaasiga ühendust ja PHP programmide turvalisust.
Veebiserver
Veebiserveriks nimetatakse:
1. Arvutiprogrammi mis saab üle interneti või kohtvõrgu veebikliendilt ( brauser  ehk  veebilehitseja ) HTTP päringuid ja  saadab  tagasi
HTTP vastuse, sisaldades peamiselt veebilehti ja faile, mis on veebilehega seotud (pildid, javascriptid,  flash -objektid jne.).
2. Arvuti, kus  jookseb  eelpool punktis defineeritud  arvutiprogramm .
Veebiserveri- ja kliendivaheline suhtlus näeb välja järgmiselt:
Antud kursuse jooksul töötame  Apache  veebiserveriga, sest see on lihtne, töökindel ja tasuta veebiserver ning lisaks tänapäeval ka
kõige  populaarsem  veebiserver maailmas. Apache esimene  versioon  sai valmis aastal 1995. Tänaseks kasutab Apache veebiserverit
umbes 50% kõigist veebisaitidest ja veebiserver on kättesaadav nii  Linux ,  Windows  ja Mac opsüsteemidele.  Tarkvara  lähtekood on
avalik, seetõttu on Apache'i jaoks olemas palju teiste arendajate poolt loodud lisateeke.
Tootja
Nimetus
Saitide arv
Protsent
Apache
Apache
83 206 564
50.22%
Microsoft
IIS
58 540 275
35.33%
Google
GWS
10 075 991
6.08%
Netcraft veebiserverite uuring. Aprill 2008 (värskemad uuringu tulemused - 2009 a.)
PHP keel
PHP on serveripoolne skriptikeel, mis võimaldab genereerida dünaamilisi veebilehti. Selle nimi pärineb kõige  esimesest  versioonist, mida
nimetati "Personal Home Page Tools". Täna nimetatakse seda kui "PHP: Hypertext Preprocessor" (hüperteksti-eeltöötleja). PHP skripti
sisaldavale HTML lehele  omistatakse  tavaliselt  laiend  .php. PHP on tasuta tarkvara ja seda levitatakse  Open  Source litsentsi all avaliku
lähtekoodina. PHP's on võimalik luua ka command-line tarkvara ning visuaalse kasutajaliidesega tarkvara, mis on aga  vastuolus  selle
programmeerimiskeele definitsiooniga. Programmeerimiskeele ajalugu algas 1994. aastast, kui Rasmus Lerdorf tegi väga lihtsa
programmi, mis  mõistis  spetsiaalseid makrosid. Aja jooksul programmi modifitseeriti, laiendati, integreeriti andmebaaside ja uute
tehnoloogiate  toega  ning lisati objekt-orienteeritud  kontseptsiooni  jne. Tulemuseks on PHP viies versioon.
Kui vaatame programmeerimiskeelte populaarsust, siis näeme, et PHP on praegusel hetkel kolmandal kohal (eelmisel aastal aga
viiendal). Arvestada tuleks ka sellega, et PHP on põhimõtteliselt serveripoolne skriptikeel.  Java , C, C++ ja  Visual   Basic  – neid
kasutatakse rohkem tarkvara loomiseks aga see ei tähenda seda, et neid ei või kautatada ka veebiinfosüsteemide loomisel.
Koht
Programmeerimiskeel
Reiting
1
Java
18.718%
2
C
16.891%
3
PHP
10.390%
4
C++
9.911%
5
(Visual) Basic
8.729%
6
C#
4.433%
7
Perl
3.776%
TIOBE Programming Community Index. Oktoober 2009 (vaata lähemalt)
Koht
Programmeerimiskeel
Reiting
1
Java
20.949%
2
C
15.565%
3
C++
10.954%
4
(Visual) Basic
9.811%
5
PHP
8.612%
6
Python
4.565%
7
Perl
4.419%
TIOBE Programming Community Index. Oktoober 2008
PHP tööprintsiip
Kõigepealt  moodustab kliendi brauser html päringu ja saadab selle vastavale  aadressile  (näiteks  http://www.site.ee/index.php ). Sellel
aadressil asuv server võtab vastu html päringu, vaatab, et temalt nõutakse .php laiendiga faili (antud juhul index.php) ja veebiserver
käivitab PHP parseri, mis loob sellest .php  failist  baitkoodi. Seejärel interpreteerib  Zend   Engine  baitkoodi ja  tagastab  veebiserverile html
koodi, mis  saadetakse  veebiserveri poolt omakorda kliendi brauserile http vastusena.
PHP's tehtud
Facebook  -  http://www.facebook.co m
Tuntud sotsiaalvõrk (rohkem kui 90.000.000 aktiivseid kasutajaid)
Flickr  –  http://www.flickr.co m
Online piltide  haldur  (rohkem kui 4.000.000.000 päringuid päevas)
Digg  –  http://digg.com/
Informatsiooni vahetamise  portaal  (rohkem kui 26.000.000 külastajaid kuus)
Wikipedia –  http://www.wikipedia.org/
Veebipõhine entsüklopeedia (rohkem kui 251.000.000 külastajaid kuus)
Lisalugemist
Veebiserveritest (www) - inglise keeles
Apache home page (www) - inglise keeles
Apache põhjalik kasutusjuhend (www) - eesti keeles
PHP  programmeerija  piibel (www) - inglise keeles
Video
Programmeerimiskeeled (3:08) (www) - inglise keeles
Serveripoolsed skriptikeeled (6:50) (www) - inglise keeles
 
1.2 Installeerimine
Klient-server arhitektuur, millest oli jutt peatükkis 1.1 nõuab vähemalt 3 elementi: kliendi arvutit, võrguühendust ning veebiserveri ja
muu vajaliku tarkvaraga serveri arvutit. Arendamise etapil piisab tihti ainult ühest lokaalarvutist, millele on installeeritud brauser
(klient), veebiserver (server) ja php interpretaator – selle arhitektuuriga pole vaja internetiühendust ja kogu töö võib teha oma
koduarvuti taga.
Loomulikult võib installeerida kõik komponendid eraldi, aga nende ühendamine ehk konfigureerimine võtab rohkem aega ja nõuab
rohkem kogemust ja teadmisi. Seega kursuse ülesannete lahendamiseks kasutame distributiivide kogumikku EasyPHP, mis sisaldab
endas järgmisi komponente: Apache, PHP, MySQL ja  PhpMyAdmin  (visuaalne veebipõhine klient MySQL andmebaasile). EasyPHP on
olemas ainult Windows operatsioonisüsteemi jaoks. Kui teie arvutis on Linux, MacOS või  Solaris  süsteem siis võib olla juba vaikimisi
Apache veebiserver ja php installeeritud. Kui ei ole siis võite proovida installeerida XAMPP kogumikku. Kui on piisavalt vaba aega ja
sihikindlust võib proovida Apache (download) ja PHP (download) eraldi iseseisvalt installeerida ja konfigureerida.
PHP programmide kirjutamiseks on vaja tekstitoimetajat. Tekstitoimetajate valik on puhtalt maitse asi, aga oleks mugavam, kui selles
on süntaksi  värvimise  tugi olemas - siis on lihtsam koodist aru saada ja selles orienteeruda. Mina soovitaks kasutada Notepad++, see on
päris võimekas  toimetaja  ning seda saab endale tasuta.
EasyPHP (EasyPHP-2.0b1) installeerimine Windows opsüsteemil
Järgmine kasutusjuhend on kirjutatud EasyPHP-2.0b1 installeeriminse jaoks (aasta 2008). Praegune versioon, mida soovitan kasutada
on EasyPHP-5.3.0. Selle paigaldus ei erine eelmistest versioonidest. Tegelikult võib vabalt kasutada ka EasyPHP-2.0b1 kuna selle
kursuse raames  versioonide  erinevus pole oluline.
Lae alla EasyPHP installeerimis fail: EasyPHP-2.0b1-setup.exe või EasyPHP-5.3.0-setup.exe
või siis otse sourceforge lehelt: EasyPHP
Juhul kui masinas on  Skype  käivitatud - lülita see installeerimise ajaks välja.
Käivita allalaetud EasyPHP-xxx-setup.exe fail.
Järgige  samme  1-8:
samm 1
samm 2
samm 3
samm 4
samm 5
samm 6
samm 7
samm 8
EasyPHP  käivitamine
Kui installeerimine on lõppenud peab taskbaris ilmuma EasyPHP  ikoon .
Klikkige sellel ikoonil kaks korda, siis ilmub  ekraanile  EasyPHP kontrollpaneel:
Juhul kui teie arvutis on installeeritud Skype, siis võib juhtuda, et Apache veebiserveri käivitamisel tekib järgmine  veateade : Apache2
port (80) is used by "skNotifyForm" (Skype.exe)!. Selle põhjuseks on see, et Skype reserveerib endale pordi 80 ja Apache
vaikimisi port on alati 80 ning tekib konflikt. Et probleemi lahendada tuleb Skype välja lülitada, käivitada Apache ja seejärel Skype.
Kui Apache teie  masinal  käib,  avage  brauser ja  pange  aadressiks  http://127.0.0.1/  või  http://localhost/ . Nende  aadresside
tähendus on " lokaalne  arvuti" (ehk 127.0.0.1 ja localhost on alati arvuti enda aadressiks).
Peab ilmuma järgmine  veebileht :
Nüüd kui veebiserver (Apache), PHP ja MySQL andmebaasi server ning tekstitoimetaja on teie arvutis olemas ja töötavad, võime jätkata
esimese PHP programmiga.
Lisalugemist
Localhost (www) - inglise keeles
Scribd
Install Apache 2.2.11 on Windows (www) - inglise keeles
 
1.3 Esimene programm
Hello  world!
Leidke oma arvutis EasyPHP kaust ja selles omakorda kaust www - see on meie Apache veebiserveri juurkataloog ehk DocumentRoot.
Looge selles kaustas fail nimega hello_world.php. Avage see fail oma teksti redaktoris ja kirjutage sinna järgmised koodi read:
hello_world.php
    
    
    
Näide 1.3.1
Salvestage fail ja käivitage brauser ning aadressiks kirjutage:  http://localhost/hello_world.php, tulemusena peab ekraanile ilmuma
järgmine väljund:
Juhul kui näide käivitamine ebaõnnestus, kontrollige kas Apache veebiserver käib ja hello_world.php fail on Apache veebiserveri
juurkataloogis olemas (www kaust).
PHP märgendid
Uurime näide 1.3.1 koodi lähemalt. Esimene asi, mida tuleb meelde jätta on see, kuidas PHP programmi koodi sisestatakse HTML koodi.
Selleks kasutatakse PHP märgendeid ja nende vahel  kirjutatakse  juba PHP kood:
1. 
2. 
3.  ... 
4. 
Tekst nende vahel interpreteeritakse PHP koodina. Kõike, mis nende sümbolite vahele ei jää, loetakse HTML koodiks ja faili täitmisel
väljastatakse  selliselt  nagu on. Kaks esimest  varianti  on kõige rohkem levinud stiil ja peamiselt kasutatakse selliseid märgendeid (selle
kursuse jooksul kasutame ainult esimest varianti).
Kommentaarid
Näide esimesel  real  asub kommentaar Kirjuta valjundisse "Hello, World!". Kommentaare kasutatakse selleks, et teised inimesed
saaksid koodist aru (eriti vajavad kommenteerimist teie poolt välja mõeldud algoritmid ja keeruline  loogika ). Mõnikord juhtub ka nii, et
2-3 kuu pärast ei oska ka koodi autor seletada kuidas tema programm töötab ja temal läheb suhteliselt palju aega selleks, et seda
meelde tuletada. Aga kui kommentaarid on olemas piisab selleks ~5 minutist. Kommentaarid peavad kirjeldama loodava koodi
eesmärke, kasutatud muutujaid, funktsioone ja algoritme. PHP parser ei loe teksti, mis asub kommentaaride vahele. Ta lihtsalt
ignoreerib seda. PHP programmeerimiskeeles on 2 tüüpi kommentaare:
1. / voi # - üherealiste märkuste jaoks
2. /* ... */ - mitmerealised kommentaarid
comments.php
Näide 1.3.2
Eraldajad
PHP  programmid  on põhimõtteliselt käskude kogumid. Käskude eraldamiseks kasutatakse programmeerimiskeeltes spetsiaalseid
sümboleid - eraldajaid. PHP's seda tehakse semikooloniga:
separators.php
Näide 1.3.3
Echo
Järgmine on sõna echo. See on keelekonstruktsioon, mida kasutatakse sõnede kirjutamiseks väljundisse (meie juhul html faili).  Sõned
peavad olema kas jutumärkides (" ") või ülakomades (' '). Kui sõne on jutumärkides, siis esimene asi mis PHP parser selliste sõnedega
teeb - püüab leida nendes muutujaid ja  asendada  neid nende väärtustega. Kuna ülakomades sõnedega  niimoodi  ei  tehta , töödeldakse
neid kiiremini. Echo käsu jaoks peab olema defineeritud vähemalt üks  parameeter , aga neid võib olla ka rohkem - siis neid tuleb
eraldada  komadega . Testimiseks käivitage järgmine fail:
echo.php
Näide 1.3.4
PHP käsurealt
Mõnikord võib tekkida vajadus PHP koodi käivitada masinas, kus veebiserverit pole. Siis PHP koodi võib käivitada ka käsurealt (ilma
veebiserverita ja brauserita). Selleks ava Windows opsüsteemis käsurea paneel (fail C:\Windows\system32\cmd.exe). Paneeli võib
käivitada ka järgmiselt: Start → Run → cmd. Käsurea paneelis mine EasyPHP www kausta ( käsk : cd), siis lisa tee php5 kaustani (käsk:
set  path ). Nüüd võid käivitada php  programme  lihtsalt kirjutades: php sinu_programm.php:
Lipp  -r võimaldab kirjutada koodi otse käsureal:
Lisalugemist
Echo (www) - inglise keeles
PHP Märgendid (www) - inglise keeles
Eraldajad (www) - inglise keeles
Kommentaarid (www) - inglise keeles
PHP käsurealt (www) - inglise keeles
Video
Esimene PHP  skript  (www) - inglise keeles
 
2.1 Muutujad
Koodi täitmise ajal paiknevad kõik  koodis  kasutatavad väärused operatiivmälus. Muutujad on lihtsalt  nimelised  "mälupesad", millesse
võib  salvestada  mingeid väärtusi ja  muutuja  nime kaudu viidatakse väärtusele operatiivmälus. Kõik PHP muutujad algavad $-märgiga,
millele järgneb muutuja nimi. Muutuja nimi algab alati tähe või allkriipsuga, millele järgneb  suvaline  arv tähti, numbreid ja allkriipse.
Muutuja nimed on suur- ja väiketähetundlikud, mis tähendab, et muutuja $name ja $Name on erinevad muutujad.  Muutujal  on oma
andmetüüp, mis näitab, mis liiki väärtusi muutuja esindab. PHP toetab jargmisi andmetüüpe: neli  skalaar - ja kaks kompleksandmetüüpi.
Lisaks on olemas ka kaks spetsiaalset tüüpi.
Skalaarsed tüübid
Tõeväärtustüüp - boolean
Võib omandada väärtusi kas true (tõene) või  false  (väär).
Näide
Täisarvutüüp - integer
Täisarv  vahemikus -2147483647 ... 2147483647. Vaikimisi kasutatakse  kümnendsüsteemi , kaheksandsüsteemi puhul arv peab algama
nulliga ning kuueteistkümnendsüsteemi puhul 0x-ga.
Näide
Ujukomatüüp -  double
Reaalarv  vahemikus -1.8 x 10308 ... 1.8 x 10308. Neid võib esitada tavalises  vormingus : täisosa. murdosa , alternatiivina võib suuri või
väga väikseid arve esitada eksponentsiaalkujul (ujukomaarvuna).
Näide
Tekstitüüp -  string
Sõned peavad olema kas jutumärkides (" ") või ülakomades (' '). Kui sõne on jutumärkides, siis esimene asi mis PHP parser selliste
sõnedega teeb - püüab leida nendes muutujaid ja asendada neid nende väärtustega. Kuna ülakomades sõnedega niimoodi ei tehta,
töödeldakse neid kiiremini. Tahtes aga ülakomades teksti sisse samuti ülakomasid kirjutada, tuleb nende ette panna langjoon \. Samuti
kui soovid jutumärkides teksti sisse paigutada jutumärkid, tuleb nende ette panna langjoon \.
Näide
Komplekstüübid
Massiiv  -  array
Massiiv on andmestruktuur, mis kujutavad ennast elementide hulga. Teisi sõnu,  massiivid  on omapärased konteinerid, mis võivad hoida
samaaegselt mitu väärtust. Vaatleme neid eraldi peatükis 4.
Näide
Objekt -  object
Programmeerimise  mõistes objekt on teatud hulk muutujaid,  välju  koos teatud hulga meetoditega, mis opereerivad muutujate
väärtustega. Muutujaid ja  meetodeid  käsitletakse ühe  tervikuna . Analoogias reaalse eluga võib muutujaid mõista näiteks kui mingi
eseme kirjeldust ja meetodeid kui tegevusi, mida selle esemega on võimalik teha. Objekte vaatleme lähemalt peatükis 5.
Näide
Spetsiaalsed  tüübid
Ressurss -  resource
See on mingi ressurss, mida PHP töötleb eri viisil. Näiteks muutuja, mis hoiab avatud faili või andmebaasiga ühenduse deskriptorit. Selle
andmetüübiga tutvume peatükis 7.
Näide
NULL
Muutuja on NULL tüüpi siis, kui ei ole määratud mingi väärtus. NULL tüüpi muutujal on üks võimalik väärtus ja see on NULL. NULL tüüpi
mutuja tekib siis, kui:
muutuja väärtuseks oli määratud NULL
muutuja oli defineeritud aga tal pole veel väärtust
muutuja oli unset()
Näide
Muutujate funktsioonid
var_export()
Tulemuseks on muutuja tekstiline kuju. Esimene parameeter on muutuja ise, teine argument on tõeväärtus, mis ütleb kas muutuja
string'i on vaja kohe väljundisse saata või string'i tagastada. Vaikimisi teine parameeter on väär (false).
Näide
is_bool(), is_int(), is_double(), is_string(), is_array(), is_object(), is_resource(), is_null()
is_N() tagastab TRUE väärtuse, kui muutuja on N tüüpi
Näide
gettype()
Tagastab muutuja väärtuse tüübi
Näide
     
     
           body  {
               padding: 15px;
                color :  black ;
                font -family: Arial;
               font- size : 14px;
          }
          .table {
               background: #696969;
          }
          .table td {
               background: white;
               padding: 5px 10px;
               font-size: 12px;
               font-weight: nornal;
               text- align :  left ;
          }
          .table th {
                width : 120px;
               background: #A5A5A5;
               color: white;
               padding: 5px 10px;
               font-size: 12px;
               font-weight:  bold ;
               text-align: left;
          }
     
     
     
          Variable
          Type
           Value
     
     
     
     
Väljundiks on järgmine tabel:
Variable
Type
Value
$a
boolean
false
$b
integer
4
$c
double
4.1
$d
string
'Hello World!'
array ( 0 => -9, 1 => true, 2 => 'word', 3 => 0,
$e
array
4 => -4.2, )
$f
object
testClass::__set_state(array( 'var' => 234, ))
$g
resource
$h
NULL
NULL
isset()
Tagastab TRUE väärtuse, kui muutuja on deklareeritud
Näide
empty()
Tagastab TRUE väärtuse, kui muutuja on deklareerimata või omab tühi-väärtust (NULL, 0, tühi string)
Näide
 
2.2 Konstandid
Nagu  enamuses  programmeerimiskeeltes PHP-s on võimalik kasutada  konstante . Konstante on mõtet kasutada muutuja asemel juhul
kui tegu on muutujaga mille väärtus ei muutu kogu programmi jooksul. Konstantide kasutamise eelised on:
1. konstantide väärtused on konstantsed - defineerides konstandi ja  andes  talle mingi väärtuse see ei muutu kunagi
2. Konstandid on globaalsed - kord defineeritud konstante saab kasutada üle terve programmi
Konstandi defineerimisel kasutatakse direktiivi  define ('konstandi_nimi', konstandi_väärtus). Konstanti võib kasutada nagu muutujat,
kuid tema ette ei tule $ märki. Konstandi kontrollimiseks võib kasutada funktsiooni defined('konstandi_nimi'), mille väärtus on TRUE,
kui konstant on defineeritud, vastasel juhul väärtuseks on FALSE. Heaks kombeks on kirjutada konstantide nimed suurte tähtedega.
Näide
PHP-s on olemas ka sisseehitatud konstandid:
__FILE__ - hetkel parsitava faili nimi
PHP_VERSION - php versioon
PHP_OS - operatsioonisüsteem
jne...
Lisalugemist
Maagilised konstandid (www) - inglise keeles
Sisseehitatud konstandid (www) - inglise keeles
 
2.3  Tehted
Tehted tõeväärtustega
Põhilised boolean tüübile rakendatavad operatsioonid on järgmised:
! -  eitus  (loogiline ei)
&& - konjunktsioon (loogiline jah)
|| -  disjunktsioon  (loogiline või)
Tehete   prioriteedid  (kahanevalt): eitus, konjunktsioon, disjunktsioon.
Tehete tulemusi võib esitatada järgmise tõeväärtustabeliga:
$a &&
$a
$b
!$a
$a || $b
$b
true
true
false
true
true
true
false
false
false
true
false
true
true
false
true
false
false
true
false
false
Loogilistele avaldistele rakendavatel tehetel on järgmised omadused:
kommutatiivsus
$a && $b == $b && $a
$a || $b == $b || $a
assotsiatiivsus
$a && ($b && $c) == ($a && $b) && $c
$a || ($b || $c) == ($a || $b) || $c
distributiivsus
$a && ($b || $c) == ($a && $b) || ($a && $c)
$a || ($b && $c) == ($a || $b) && ($a || $c)
de Morgani reegel
!($a && $b) == !$a || !$b
!($a || $b) == !$a && !$b
Näide
Aritmeetilised tehted
+    summeerimine
-   lahutamine
*    korrutamine
/   jagamine
%   jäägiga jagamine
++   inkrement
--   dekrement
Tehete tulemusi võib esitatada järgmise tabeliga:
$a
$b
$a+$b
$a-$b
$a*$b
$a/$b
$a%$b
$a++
$a--
5
3
8
2
15
1.66...
2
6
4
-5
2
-3
-7
-10
-2.5
-1
-4
-6
Näide
Inkremendi ja  dekremendi  põhimõte on järgmine:
$a++; on sama mis $a = $a + 1 või $a += 1;
$a--; on sama mis $a = $a - 1; või $a -= 1;
Ühendatud määramisoperaatorid
Ьhendatud määramisoperaatorid koosnevad tavaliseslt ühest aritmeetilisest operaatorist, millele järgneb  võrdusmärk . Nende
operaatorite eesmärk on kiirendada koodi kirjutamist ja muuta kood loetavamaks. Ьhendatud määramisoperaatorid on välja toodud
allolevas  tabelis.
Operaator
Näide
On sama kui
$a += 2
$a = $a + 2
$a -= 2
$a = $a - 2
$a *= 2
$a = $a * 2
$a /= 2
$a = $a / 2
$a %= 2
$a = $a % 2
$a .= 'text'
$a = $a . 'text'
Võrdlemine
==   võrdsed (väärtused on võrdsed)
===   ekvivalentsed (tüübid ja väärtused on võrdsed)
!=   mittevõrdsed
!==   mitteekvivalentsed
>   suurem
>=   suurem või võrdne
Näide 2.4.1
Uurime näide 2.4.1 koodi lähemalt.
function  getDiscriminant ($a, $b, $c)
function tähendab seda, et tegemist on funktsiooniga.
getDiscriminant on funktsiooni nimi (funktsiooni nimi algab alati tähe või allkriipsuga, millele järgneb suvaline arv tähti, numbreid ja
allkriipse). Nimi ei tohi kattuda PHP funktsioonide nimedega. Funktsiooni nimed ei ole suur- ja väiketahetundlikud, mis tähendab, et
funktsioonid getName() ja GETnAme() on üks ja sama funktsioon.
$a, $b, $c on funktsiooni  parameetrid , neid kasutatakse selleks et funktsiooni käivitamisel  edastada  funktsioonile andmeid. Funktsiooni
välja kutsudes peavad olema kindlasti antud parameetrid $a, $b ja $c.
Funktsiooni sees asub tavaline PHP kood
return  $D on naasmisdirektiiv mida kasutatkse väärtuste tagastamiseks funktsioonist (naasmisdirektiiv võib ka  puududa  - siis tihti
nimetatakse sellise funktsiooni protseduuriks).
Funktsiooni  väljakutsumine  on lihtne ja see ei erine  tavaliste  PHP funktsioonide väljakutsumisest. Kui kutsume välja funktsiooni ja
soovime  selle väärtust muutujas salvestada, siis näeb see välja nii:
$var = funktsiooni_nimi ($param1, $param2);
Kui kutsume välja protseduuri:
funktsiooni_nimi ($param1, $param2);
Muutujad funktsioonis
Näites edastasime argumentidena kolm muutujat: $a, $b ja $c. Argumentide nimed on kasutusel ainult funktsiooni sees ja funktsiooni
väljakutsudes me ei pea kasutama samu  nimesid . Võib teha ka nii:
Näide
Eelmises näides kõik argumendid olid kohustuslikud. Vajadusel PHP-s võib argumente defineerida ka mittekohustuslikeks (juhul, kui
vabatahtlik argument puudub, asendatakse see vaikimisi määratud väärtusega, antud juhul siis  viiega ):
Näide
Funktsiooni argumendid ja funktsiooni sees defineeritud muutujad kehtivad ainult selle funktsiooni sees ning ainult väljakutsumise ajal.
Järgmine kord kui kutsume välja funktiooni defineeritakse need muutujad uuesti. See tähendab, et funktsiooni sees olevad muutujad on
lokaalsed. Kui soovime funktsiooni sees kasutada muutujaid mis olid defineeritud väljaspool funktsiooni siis tuleb enne kasutada  global
direktiivi:
Näide
Rekursiivne funktsioon
Rekursiivne funktsioon on selline funktsioon, mis kutsub iseennast välja. Rekursiivne  funktsiion  on hea siis, kui on vaja sooritada
korduvaid tegevusi. Hea näide on kaustade puu joonistamine, faktoriaali või suurima ühisteguri leidmine:
factorial.php
Näide 2.4.2
greatest_common_divisor.php
Näide 2.4.3
Lisalugemist
Rekursiivsed funktsioonid (www) - inglise keeles
PHP  matemaatilised  funktsioonid (www) - inglise keeles
PHP sõnede funktsioonid (www) - inglise keeles
Video
Funktsioonid ( osa1 , osa1, osa1) - inglise keeles
Scribd
PHP Funktsioonid (www) - inglise keeles
 
3.1 If- else
Kõik programmid, mis meie oleme vaadelnud olid hästi lihtsad selles mõttes, et käske käivitatakse
algusest lõpuni. Keerukamate programmide  kirjutamisel  on vaja käske valikuliselt täita või siis isegi
täitmata jätta. Näiteks kui meie  program  arvutab funktsiooni f(x) = 1/x väärtusi, siis juhul kui x on null
– program peab ütlema, et 0 korral funktsioon pole määratud. Programmi loogika peab siis välja nägema
järgmiselt:
Kui x on võrdne nulliga, siis
    anna veateade
vastasel korral
    arvuta 1/x ja väljasta tulemus
Sellise loogika implementeerimiseks PHP-s on olemas tingimuslaused (mõnikord neid nimetatakse
valikulauseteks) ja nende  üldkuju  on:
if (tingimus) {
     plokk1
} else {
    plokk2
}
Tingimus
Tingimus, mida kasutatakse if-else tingimuslauses on loogiline  avaldis  (lihtsam näide on võrdlemine, aga vajadusel võib kasutada ka
avaldisi mis on ühendatud && või || abil). Programmi täitmisel kõigepealt kontrollitakse tingimuse kehtivust (kehtivus tähendab seda, et
loogilise  avaldise   lõppväärtus  on tõene (true)). Juhul kui tingimus kehtib - täidetakse esimene  plokk  (2  plokki  kuuluv kood jääb
täitmata), vastasel juhul - teine plokk (1 plokki kuuluv kood jääb täitmata).
Näide
     
          x
          f(x)
     
     
          
          
     
     
          
          
     
     
          
          
     
Tulemuseks on järgmine tabel:
x
f(x)
5
0.2
0
undefined
-2
-0.5
Juhul kui else pole oluline, siis see võib ka puududa:
Näide
     
          x
          f(x)
     
     
     
     
Väljund:
x
f(x)
5
0.2
-2
-0.5
Keerulisema  tingimuslause  hea näide on liigaasta kontroll. Aasta on liigaasta juhul kui  aastaarv   jagub  4-ga ja pole nii, et aastaarv jagub
100-ga ning ei jagu 400-ga. Seda tingimust võib kirjale panna järgmiselt:
$aasta % 4 == 0 && !($aasta % 100 == 0 && !($aasta % 400 == 0))
Võime seda ka lihtsustada kasutades mittevõrdumist:
$aasta % 4 == 0 && ($aasta % 100 != 0 || $aasta % 400 == 0)
Näide
Tingimus võib eelnevalt panna ka muutujasse:
Näide
If-else  erikujud
Kui  plokis  on ainult üks käsk, siis loogilisi  sulge  võib ka ära jätta:
Näide
Lisaks PHP-s on olemas kompaktne if-else tingimuslause kuju:
tingimus ? true_plokk : false_plokk;
ja see on absoluutselt sama mis:
if (tingimus) {
    true_plokk
} else {
    false_plokk
}
Näide
Tingimus tingimuse sees
Mõnikord tuleb kasuks see asjaolu, et tingimuslause on käsk nagu iga teinegi ja seega seda võib kasutada ka teise tingimuslause sees.
Kirjutame liigaasta probleemi lahendus üle:
Näide
If- elseif -else  konstruktsioon
Juhul, kui  programmis  on vaja mitu tingimust kontrollida, siis PHP-s on olemas if-elseif-else tingimuslause konstruktsioon (else võib ka
siin puududa):
if (tingimus1) {
    plokk1
} elseif (tingimus2) {
    plokk2
} elseif (tingimus3) {
     plokk3
} else {
     plokk4
}
Kui tingimus1 on väär, siis minnakse järgmise juurde (tingimus2) kui mingi tingimus kehtib siis täidetakse vastav koodi plokk ja järmisi
tingimusi arvuti ei kontrolli. Kui kõik tingimused on väärad ja else osa on olemas, siis täidetakse seda. Elseif võib kirjutada nii palju kui
vaja on. Näiteks mängu tulemus on esitatud mingi arvuna (-1 - kaotus, 0 -  viik , 1 - võit) ja meil on vaja väljastada teade mängu seisu
kohta, siis if-elseif-else abil see on  imelihtne :
Näide
Lisalugemist
Liigaastad (www) - eesti keeles
 
3.2  Switch
PHP-s on olemas veel üks tingimuslause mille abil võib realiseerida hargnemist. See on switch ja  case  käskudest moodustatud switch-
tingimuslause. Selleks, et tulevikus vigu vältida on väga tähtis aru saada kuidas arvuti töödeldab switch lause.
Esialgul jäetakse meelde avaldis (vajadusel arvutatakse seda ka) ja sõltuvalt sellest siirdub täitmisjärg ühte või teise  harusse  - neid
tähistavad  avaldise väärtused koos case sõnaga. Lisaks konstruktsiooni lõppu võib lisada ka sõna default - seda täidetakse siis, kui
üheski case avaldise väärtusevarianti ei leidunud (sarnane else'iga). Switch-tingimuslause üldine struktuur on järgmine:
switch (avaldis) {
    case  variant1  :
         käsud ;
        break;
    case variant2 :
        käsud;
        break;
    ...
    ...
    case variantN :
        käsud;
        break;
    default:
        käsud;
}
Iga  variandi  sisu lõpetab käsk break, mis  rangelt  võttes pole küll kohustuslik, vaid pigem ülimalt soovitatav. Näiteks, eelmises osas (3.1)
if-elseif-else tingimuslause abil kirjutatud programmi võiks kirjutada kasutades ka switch tingimuslause:
Näide
Kui me ei kasuta break käsu, leiaks switch küll õige koha, kuid ei lõpetaks tööd ja täidaks ka kõik endast allapoole jäävad tingimused.
Kui on vaja, et mitme variandi puhul täidetakse samu  lauseid , siis tuleb kirjutada vastavad case-märgendid üksteise järele. Järgmine
programm väljastab hinde (0-5) sõnalisel kujul:
Näide
Case avaldise väärtusevariandid võivad olla mitte ainult arvulised vaid ka ka string tüüpi väärtused:
Näide
 
4.  Tsüklid
Programmeerimise põhiline eesmärk on anda korduvad tegevused teha  arvutile . Arvutist oleks aga hulga vähem kasu, kui puuduks
võimalus panna teda mingit ühesugust tegevust kordama mitu korda järjest. Eelnevates peatükkides vaadeldud programmidel on selline
omadus, et iga käsku täidetakse täpselt üks kord (või ei täideta üldse kui tegemist on mõne if- või switch-lause haruga). Sellised
programmid jääksid hätta, kui oleks näiteks vaja leida  Fibonacci  jada liige kohal 14.
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
F13
F14
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
Loomulikult võime kirjutada koodi, kus iga jada liige jaoks on arvutamise käik eraldi kirja pandud:
Näide
Aga nüüd selleks, et meie programm oskaks Fibonacci jada liige kohal 23 leida - peame koodi veel juurde kirjutama. Selline  lähenemine
pole eriti hea ja mugav. Seega oleks tore kui saaksime kasutada käske stiilis "täida seda programmilõiku 23 korda". Niisuguse võimaluse
annavadki meile tsüklid.
While  - eelkontrolliga  tsükkel
Eelkontrolliga tsükli ehk while-tsükli üldkuju on:
while (tingimus) {
    käsud;
}
Eelkontrolliga tsükli puhul kontrollitakse tingimus iga kord enne tsükli koodi täitmist, kas seal olevaid käske üldse on vaja täita. Pärast
ploki läbimist minnakse taas ploki  algusesse  vaatama, kas tegevust oleks vaja korrata (kas tingimuse tõeväärtus on tõene (true)).
Graafiliselt seda võib kujundada järgmiselt:
Kirjutame nüüd getFibonacciNumberAt($n) funktsiooni:
Näide
Järgmine näide väljastab Fibonacci jada n esimest elementi:
Näide
On võimalik, et tsüklitingimus osutub kohe esimesel kontrollimisel vääraks, nagu näiteks järgmises programmilõigus. Sellisel juhul ei
täideta tsükli sisu ühtegi korda.
Näide
Break ja  continue
Juhul kui on vaja mingil hetkel kohe tsükli lõpetada (näiteks tulemus on käes ja pole mõtet edasi otsida) võib kasutada break'i. Juhul
kui meie ülesanne on kotrollida kas esimese 50 Fibonacci jada elementide hulgas on vähemalt üks mis jagub 19-ga:
Näide
Ühe tsükli läbimist nimetatakse iteratsiooniks. Näiteks järgmise programmi puhul arvuti käivitab tsükli koodi kolm korda (while
tsükkel teeb kolm iteratsiooni):
Näide
Juhul, kui mingil hetkel me soovime kohe jätkata järgmise iteratsiooniga - continue käsk on meile abiks. Näiteks meil on vaja
väljastada kõik arvud vahemikus 0...100, mis  jaguvad  kolmega:
Näide
Visuaalselt  võib neid käske kujundada nii:
Do-while - järelkontrolliga tsükkel
Tsükli täitmine algab sisu koodi täitmisest, misjärel kontrollitakse tingimuse kehtivust. Nagu eelkontrolliga tsükli puhulgi, kui tingimus
kehtib, siis läheb täitmisjärg uuesti tsükli sisu algusesse, vastasel juhul - väljutakse  tsüklist  ja võetakse ette tsüklile järgnev programmi
käsk:
do {
    käsud;
} while (tingimus);
Näide
Järelkontrolliga  tsüklis  täidetakse tsükli sisu alati vähemalt üks kord:
Näide
For - kolmikpäisega tsükkel
PHP-s on olemas veel ühte tüüpi tsükkel, kolmikpäisega ehk for-tsükkel, mis küll on samaväärne  teatava  while-tsükliga, nii et sellest
lisandusest keelele uusi väljendusvõimalusi juurde ei tule. Kuid for-tsükli struktuur sobib mõnede programmide koostamiseks eriti hästi
ning teda on lihtsam konstrueerida kui vastavat while-tsüklit. For tsükli üldkuju on järgmine:
for (algatamine ; tingimus ; abitegevused) {
    käsud;
}
ja see on samaväärne eelkontrolliga while-tsükliga:
algatamine ;
while (tingimus) {
    käsud;
    abitegevused ;
}
Näiteks selle koodi asemel:
Näide
on palju mugavam kirjutada:
Näide
Korrutustabel  kahe for tsükli abil:
Näide
Tulemus:
 
1
2
3
4
5
6
7
8
9
10
1
1
2
3
4
5
6
7
8
9
10
2
2
4
6
8
10
12
14
16
18
20
3
3
6
9
12
15
18
21
24
27
30
4
4
8
12
16
20
24
28
32
36
40
5
5
10
15
20
25
30
35
40
45
50
6
6
12
18
24
30
36
42
48
54
60
7
7
14
21
28
35
42
49
56
63
70
8
8
16
24
32
40
48
56
64
72
80
9
9
18
27
36
45
54
63
72
81
90
10
10
20
30
40
50
60
70
80
90
100
Lisalugemist
Fibonacci jada (www) - inglise keeles
 
5.1 Massiivid
Üks olulisemaid andmestruktuure programmeerimises on massiivid ehk järjendid. Massiiv on indekseeritud elementide hulk, kus iga
elemendil ehk väärtusel on oma  unikaalne  indeks ehk võti. Võtmeteks sobivad  täisarvud  ja sõned, väärtusteks - ükskõik mis tüüpi
andmed (lihttüübid, massiivid, objektid jne.). PHP-s on olemas tavalised massiivid ( võtmed  on täisarvud) ja assotsiatiivsed massiivid
(võtmed on sõned). Elementide arvu massiivis pole vaja määrata selle loomise ajal (paljudes programmeerimiskeeltes massiivi
elementide arv peab olema rangelt defineeritud massiivi loomisel). PHP hoolitseb ise massiivi poolt  kasutatava  mälu eest ning muudab
massiivi suurust dünaamiliselt ning massiivi maksimaalne elementide arv on piiratud ainult masina operatiivmäluga.
Massiivi loomine ja elementide lisamine
Esimene võimalus on kasutada võtmesõna array: $massivi_nimi = array() - see kood loob massiivi $massivi_nimi, mis on esialgul
tühi (ei sisalda ühtegi elementi). Selleks, et lisada elemente massiivi lõppu, võib panna nurksulud massiivi mutuja järgi ja sulgudes
elemendi võti, siis võrdusmärk ja elemendi väärtus: $massiivi_nimi[võti] = element. Kui võti sulgudes puudub - kasutatakse
järgmist vaba indeksit. Pange tähele, et indekseerimine algab nullist!
Näide 5.1.1
Väljund
     $a size = 4
     Array
     (
          [0] => element_1
          [1] => element_2
          [4] => element_3
          [5] => element_4
     )
Sama tulemust võime saavutada ainult võtmesõna array abil kui kasutame seda kujul
array(võti => väärtus, võti => väärtus, ..., võti => väärtus)
Kui jätame ära elemendi võti siis asi toimib nagu [] korral:
Näide 5.1.2
Väljund
     $a size = 4
     Array
     (
          [0] => element_1
          [1] => element_2
          [4] => element_3
          [5] => element_4
     )
Assotsiatiivsed massiivid
Assotsiatiivse massiivi saame teha sarnaselt eelmises punktis vaadeldule. Kasutame võtmesõna array tühja massiivi moodustamiseks ja
pärast lisame elemente:
Näide 5.1.3
Väljund
     Array
     (
          [name] => Andrei
          [ gender ] =>  male
          [age] => 25
          [ student ] => 1
     )
Või siis kohe  määrame  väärtusi massiivi loomisel:
Näide 5.1.4
Väljund
     Array
     (
          [name] => Andrei
          [gender] => male
          [age] => 25
          [student] => 1
     )
Elementide kättesaamine
Massiivi elemendi poole pööratakse tema võtme järgi. Kui teame mis on elemendi võti, siis väärtust saame kätte järgmisel viisil:
$massiivi_nimi[võti]
Näide 5.1.5
Väljund
     two + three =  five
Näide 5.1.6
Väljund
     Andrei is 25  years  old.
     He is a student.
Massiivi läbimine
Tavalise massiivi puhul (võtmed on täisarvud) kui indeksid (võtmed) on 0...n - siis võime kasutada for ja while tsükleid. Sellisel juhul
tuleb kasutusele  count () funktsioon, mille abil saame teada massiivi elementide arvu. Lihtsalt käime kõik indeksid läbi. Alustame
esimesest elemendist, mille indeks on 0 ja lõpetame  indeksiga  mis on võrdne massiivi elementide arvuga  miinus  üks.
For:
Näide 5.1.7
Väljund
     $i = 0; $ numbers [$i] = $numbers[0] = one
     $i = 1; $numbers[$i] = $numbers[1] = two
     $i = 2; $numbers[$i] = $numbers[2] = three
     $i = 3; $numbers[$i] = $numbers[3] =  four
     $i = 4; $numbers[$i] = $numbers[4] = five
     $i = 5; $numbers[$i] = $numbers[5] = six
While:
Näide 5.1.8
Väljund
     $i = 0; $numbers[$i] = $numbers[0] = one
     $i = 1; $numbers[$i] = $numbers[1] = two
     $i = 2; $numbers[$i] = $numbers[2] = three
     $i = 3; $numbers[$i] = $numbers[3] = four
     $i = 4; $numbers[$i] = $numbers[4] = five
     $i = 5; $numbers[$i] = $numbers[5] = six
Aga for ja while tsüklidega läbimisel peame 100% kindel olema, et massiivi esimese elemendi indeks on 0 ja iga järgmine on eelmisest
ühe võrra suurem. Juhul kui see nii ei ole, selline algoritm ei sobi:
Näide 5.1.9
Väljund
     Array
     (
          [0] => one
          [1] => two
          [6] => three
          [7] => four
          [8] => five
          [9] => six
     )
     $i = 0; $numbers[$i] = $numbers[0] = one
     $i = 1; $numbers[$i] = $numbers[1] = two
      Notice : Undefined offset: 2 in C:\Program Files\EasyPHP 2.0b1\www\tst.php on line 10
     $i = 2; $numbers[$i] = $numbers[2] =
     Notice: Undefined offset: 3 in C:\Program Files\EasyPHP 2.0b1\www\tst.php on line 10
     $i = 3; $numbers[$i] = $numbers[3] =
     Notice: Undefined offset: 4 in C:\Program Files\EasyPHP 2.0b1\www\tst.php on line 10
     $i = 4; $numbers[$i] = $numbers[4] =
     Notice: Undefined offset: 5 in C:\Program Files\EasyPHP 2.0b1\www\tst.php on line 10
     $i = 5; $numbers[$i] = $numbers[5] =
Assotsiatiivse massiivi ja massiivi, kus elementide indeksid ei vasta  üleval  vaadeldud reeglile (0...n) - kasutame massiivi läbimiseks
foreach  tsüklit, mille üldine kuju on:
foreach ($massiivi_nimi as $muutuja_elemendi_võtme_jaoks => $muutuja_elemendi_väärtuse_jaoks) {
    käsud;
}
Foreach tsükkel käib kõik massiivi elemendid läbi ja igas iteratsioonis paneb $muutuja_elemendi_võtme_jaoks väärtuseks elemendi võti
ja $muutuja_elemendi_väärtuse_jaoks elemendi väärtus:
Näide 5.1.10
Väljund
     name: Andrei
     gender: male
     age: 25
     student: 1
Kui massiivi läbimisel võtme väärtus pole oluline, võib seda ka ära jätta:
Näide 5.1.11
Väljund
     one two three four five six
Nagu ka teistes tsüklites võib kasutada break ja continue:
Näide 5.1.12
Väljund
     one
     four
Elementide kustutamine massiivist
Selleks, et massiivi elemendi  kustutada , peame kindlasti teadma mis on elemendi võti. Elemente kustutakse võtme järgi käsu unset
abil:
Näide 5.1.13
Väljund
     Array
     (
          [0] => one
          [1] => two
          [2] => three
          [3] => four
          [4] => five
          [5] => six
     )
     deleting element with index 1
     deleting element with index 4
     Array
     (
          [0] => one
          [2] => three
          [3] => four
          [5] => six
     )
Pange tähele, et elementide võtmed jäid samaks ja nad on nüüd 0, 2, 3 ja 5. Selleks, et need oleksid kujul 0...n võib kasutada
array_values($massiiv) funktsiooni mille argumendiks on meie massiiv. Antud funktsioon tagastab uue massiivi kus on samad
elemendid kui argumendina antud massiivis, aga tagastatava massiivi võtmed on kujul 0...n:
Näide 5.1.14
Väljund
     Array
     (
          [0] => one
          [1] => two
          [2] => three
          [3] => four
          [4] => five
          [5] => six
     )
     Array
     (
          [0] => one
          [2] => three
          [3] => four
          [5] => six
     )
     Array
     (
          [0] => one
          [1] => three
          [2] => four
          [3] => six
     )
Mitmemõõtmelised massiivid
Mitmemõõtmeliseks massiiviks nimetatakse massiivi, mille elemendid on ka massiivid. Peamiselt kasutatakse neid andmete loogiliseks
struktureerimiseks. Hea näide on inimeste andmete hoidmine:
Nдide 5.1.15
Valjund
ID
Name
Gender
Age
Contacts
home: 6314981
38702128612
John  Peterson
M
38
mobile : 57123912
48112010907
Jane  Anderson
F
29
mobile: 50929101
home: 7430921
34908119132
Mike  Jameson
M
50
mobile: 58829120
Lisalugemist
Massiivi funktsioonid (www) - inglise keeles
 
6.1 Klassi ja objekti mõisted
Siiani oleme tegelenud programmidega, mis koosnesid ainult funktsioonidest. Nüüd tutvume ka klassidega. Kui soovime koostada
süsteemi, mis peab lahendama mitu ülesannet, siis on väga kasulik jagada süsteemi lihtsamateks  osadeks  ning kirjutada
lahendamisalgoritm eraldi iga osa jaoks ja siis pärast ühendada need algoritmid. Mitme väiksema osa programmeerimine on alati
lihtsam kui süsteemi kirjutamine tervikuna. Ka edaspidi on sellise süsteemi täiendamine ja parandamine lihtsam ja sellega ka odavam.
Programmeerimise algusaegadel võeti  moodulite  väljaeraldamisel aluseks tegevused, ülesande lahendamist vaadeldi tegevuste
järjendina, millest püüti välja eraldada alamtegevused. Viimaste jaoks oli võimalik koostada  omaette  lahendamisalgoritm. Väga sageli
esinevateks alamülesanneteks on näiteks järjendi elementide summa leidmine, kahe arvu väärtuste vahetamine,
lineaarvõrrandisüsteemi lahendamine jms.
Selline lähenemisviis on väga hea siis, kui arvuti lahendab peamiselt arvutuslikke ülesandeid, aga osutub raskepäraseks juhul, kui vaja
on töödelda mittearvulist infot. Seepärast on osutunud loomupärasemaks võtta programmi koostamisel aluseks mitte tegevused, vaid
objektid, millega tegevusi tehakse. Viimane põhimõte kehtib ka PHP's, seepärast nimetatakse seda objektorienteeritud
programmeerimiskeeleks.
Objekt (object)
Objekt on  kompleks  andmetüüp, mis on lihtsalt funktsioonide (objekti funktsioone  nimetakse  tihti objekti meetoditeks) ja muutujate
(objekti muutujaid nimetakse tihti objekti väljadeks) kogu, mis on loogiliselt selle objektiga seotud. Analoogias reaalse eluga võib
muutujaid mõista kui mingi eseme kirjeldust ja meetodeid kui tegevusi, mida selle esemega on võimalik teha. Näiteks kui meil on
tegemist objektiga 'Inimene', siis objekti väljad on nimi, sugu, abikaasa, lapsed, elukoht, töökoht ja objekti meetodid on siis nime
muutmine,  abiellumine , lahku  minemine , töö- ja elukoha muutmine jne. Väljade ja meetodite valik sõltub süsteemi nõuetest ja
arhitektuurist . Näiteks pangasüsteemis võib tarvis minna objekti 'Pangakaart', mille väljadeks on kaardi number, omaniku nimi,
rahasumma , lukustusindikaator ning meetoditeks näiteks kaardil oleva rahasumma  suurendamine  mingi väärtuse võrra, rahasumma
vähendamine, kaardi lukustamine, lukustuse tühistamine.
Objekti muutuja loomine on sama lihtne kui tavalise muutuja puhul. Esialgul kirjutatakse muutuja nimi ja seejärel  luuakse  uus klassi
objekt kasutades konstruktsiooni new ClassName(parameetrid);.
Näide 6.1.1
Väljund
     Type: object
      Class : Inimene
Klass (class)
Klass on lihtsalt objekti andmetüübi kirjeldus. Hea praktika on kirjutada  klasse  eraldi failidesse nimedega 'ClassName.php'. Klassi
kirjeldatakse plokis class . Klassi arhitekruur on tavaliselt järgmine:
Näide 6.1.2

Väljade defineerimisel on võimalik määrata ka ligipääsu direktiivi (piirajat). Võimalikud  direktiivid :
public - avalik ligipääs, klassi muutujate väärtusi saab vabalt kätte saada ja muuta ning klassi funktsioone käivitada kõikjal
private -  privaatne  ligipääs, muutujad ja funktsioonid on kättesaadavad vaid selles klassis
protected  - kaitstud ligipääs, muutujad ja funktsioonid on kättesaadavad selles klassis ja selle klassi laiendavates klassides
Direktiivide kasutamise  näided  on olemas osas 6.2.
Igas klassis on vaikimisi olemas konstruktor - meetod, mida käivitatakse siis, kui klassi objekti luuakse, ehk siis iga kord kui kirjutame
koodis new ClassName(); Seda meetodit võib ka käsitsi ümber defineerida, selleks on olemas meetod __construct(...). Näiteks meie
näides konstruktoris määratakse kohe inimese nimi ja sugu. Lisaks __construct funktsioonile on olemas ka järgmised "maagilised"
funktsioonid: __destruct, __call, __callStatic, __get, __set, __isset, __unset, __sleep, __wakeup, __toString, __invoke, __set_state,
__clone. Selle kusrsuse raames kasutame ainult __construct ja __toString.
Konstruktori, destruktori ja __toString näide:
Näide 6.1.3
Väljund
     Konstruktor
     Hello World!
     Destruktor
Lisalugemist
Maagilised funktsioonid (www) - inglise keeles
 
6.2 Klassi kirjutamine ja objekti kasutamine
Enne klasside kirjutamist on vaja hoolikalt läbi mõelda, mis klasse on vaja antud süsteemi realiseerimiseks, mis peavad olema nende
väljad ja meetodid. Alles siis, kui analüüs on tehtud ja klasside nimekiri on kirjas - siis võib alustada klasside ja nende loogika
kodeerimisega.
Klassi kood
Iga klass algab sõnast class ja klassi nimest, millele järgneb klassi keha:
class ClassName {
     
     // klassi keha
     
Klassi sees esimesena deklareeritakse klassi muutujad koos ligipääsu direktiividega:
class ClassName {
     
     // klassi muutujad
     
     public $a;
     public $b;
     
     private $c;
     private $d;
     private $e;
     
     protected $f;
     
Järgmine on konstruktor (juhul, kui seda on vaja) ja peale seda klassi meetodid:
class ClassName {
     
     // klassi muutujad
     
     public $a;
     public $b;
     
     private $c;
     private $d;
     private $e;
     
     protected $f;
     
     // klassi konstruktor
     
     public function __construct() {
          ...
          ...
          ...
     }
     
     // klassi meetodid
     
     public function f1 () {
          ...
          ...
          ...
     }
     
Selleks, et klassi sees interpritaator saaks aru millal on tegemist klassimuutujaga ja millal mitte - tuleb klassi muutuja ette panna
$this-> ja muutuja nimi. Seega klassis MingiKlass rida $this->a = 9; tähendab: leia selles klassis muutuja a ja pane talle väärtuseks
9. Sama moodi on ka klassi meetoditega - kui mingi klassi meetod peab käivitada mingit teist meetodit selles samas klassis - siis
lisatakse funktsiooni ette konstruktsioon $this->:
Näide 6.2.1
Väljund
     object(A)[1]
        public 'x' => int -1
        public 'y' => int -2
        public 'z' => int -3
Klassi muutujatele ja funktsioonidele juurdepääsu väljaspoolt klassi saab ka sarnasel moel, aga siis $this-> asemel tuleb kirjutada
$objektiNimi->.
Näide 6.2.2

Juurdepääsu direktiivid
Kui klassimuutuja ligipääs on public - siis neid võib vabalt muuta ja väärtustada ka väljaspoolt klassi. Miks selline lähenemine võib halb
olla? Oletame, et meil on klass B ja selle muutuja x on public ligipääsuga. Kogu süsteemi koodis väärtustakse x muutujat otseselt
($b->x = mingi arv) ja väärtuseks võib olla nii täisarv kui ka  murdarv . Nüüd mõni aja pärast otsustame, et klassi B muutuja x väärtus
võib olla ainult täisarv - aga siis on vaja vaadata kogu kood üle ja lisada  round () funktsiooni seal, kus x väärtuseks pannakse murdarv.
class B {
     
     public $x;
     
$b = new B();
$b->x = 5;
// ...
// ...
$b->x = 4.9;
//...
$b->x = -7.1;
Tavaliselt määratakse kõigile klassi muutujatele private juurdepääsu ja kogu kommunikatsioon klassi muutujatega toimub läbi klassi
funktsioone. Sellel juhul klassi B muutuja x väärtustamiseks tuleb kasutada funktsiooni, näiteks $b->setX(mingi arv). Nüüd kui oleks
vaja süsteemi ümber ehitada nii, et x väärtused oleksid ainult täisarvud, võib seda teha ainult lisades round() klassi B meetodi setX
juurde. Muutuja x väärtuse saamiseks kirjutame lisaks ka funktsioon  getX , sest juhul, kui proovime privaatse muutuja x väärtust saada
otseselt -  visatakse  veateade.
class B {
     
     private $x;
     
     public function setX ($value) {
          $this->x = round($value);
     }
     
     public function getX() {
          return $this->x;
     }
     
$b = new B();
$b->setX(5);
// ...
// ...
$b->setX(4.9);
//...
$b->setX(-7.1);
Näide
Kujutame ette, et ühel ettevõttel on vaja kirjutada väike veebiinfosüsteem, mis on seotud töötajate haldamisega. On olemas  andmebaas
inimeste nimedega ja isikukoodidega. Meie süsteem peab oskama isikukoodi järgi öelda, kas tegemist on mehega või naisega ja lisaks ka
isikukoodist võtta isiku sünnipäeva. Kirjutame klassi Human (fail Human.php), mille väljad on vastavalt siis  eesnimi , perekonnanimi ja
isikukood . Lisame klassi ka funktsioone isikukoodi parsimiseks ( http://et.wikipedia.org/wiki/Isikukood ):
Naide 6.2.3 (Human.php)

Selleks, et klassi Human kasutada mingis skriptis tuleb seda skripti lisada. Failide laadimiseks skripti käigus kasutatakse  include  ja
require  käske. Nende abil võib  laadida  ükskõik mis failid (*.php, *.html, jne) ning juhul kui laetavas  failis  on php kood olemas siis seda
käivitatakse. Et vältida mitmekordset ühe ja sama faili laadimist kasutatakse include_once ja require_once - need käsud kontrollivad,
kas nõutud fail on juba laetud või mitte ja kui fail on juba laetud - koodi täitmine läheb edasi, vastasel juhul - laetakse faili.
Naide 6.2.4

     
          Name
          Gender
           Birthday
     
     
          
               
               
               
          
     
Valjund
Name
Gender
Birthday
John Doe
Male
28.12.1983
Mary  James
Female
13.08.2001
 
6.3 Klassi pärilus
Pärilus on väga tähtis objektorienteeritud programmeerimises. Loomulikult toetab seda ka PHP. Päriluse mõte on selles, et on võimalik
kijutada üldisemaid klasse, ja  nendest  juba põlvnevad spetsiifilisemad alamklassid ehk  tuletatud  (derived)  klassid . Ja nendest võib
omakorda põlvneda veel mõned teised klassid. Sellel moel tekib  hierarhiline  struktuur, milles iga klass kasutab ära oma vanem- või
ülemklassi  ehk baasklassi ( base  class) omadusi. Tuletatud klass ei pea ise  defineerima  välju ja funktsioone mis on tema baasklassides
juba olemas, ainuke asi mis tuletatud klassis on vaja kodeerida - mingid spetsiifilised meetodid ja ainult sellele klassile vajalikud väljad.
Selleks, et näidata et mingi klass põlvneb mingist  klassist  kasutatakse võtmesõna extends ( laiendab ) klassi päises. Kui tuletatud klassis
on vaja baasklassi funktsiooni üle kirjutada (override) - siis lihtsalt kirjutame tuletatud klassi funktsiooni sama nimega (näides on
niimoodi tehtud sayHello() meetodiga).
Näide 6.3.1
Väljund
       class B
       ABSum: 25 (päritud meetod)
       Min: 10
       Max: 20
Baasklassi ülekaetud meetodi käivitamine alamklassis
Mõnikord tekib vajadus pöörduda baasklassi meetodi (samuti ka muutuja) poole. Juhul, kui see meetod on päritud baasklassist - siis pole
probleemi ja $this->methodName() teeb oma tööd ilusti. Aga mis siis teha kui baasklassi meetod on juba ülekaetud antud klassis, sest
$this->methodName() kutsub selles klassis olevat funktsiooni. Selleks on olemas võtmesõna  parent . Tuleb kirjutada
parent::methodName() ja sellega pöördume juba kindlasti baasklassi meetodi poole. Pange tähele, et ka maagilisi funktsioone võib
niimoodi kätte saada.
Näide 6.3.2
Väljund
       5, 6, 7
       sum: 18
       --------------
       1, 2, 3, 4
       sum: 10
Pärilus ja ligipääsu direktiivid
Nagu on juba  mainitud , private teeb muutujat või funktsiooni nähtavaks ainult selles klassis kus nad on defineeritud. Sama lugu on ka
pärilusega. Juhul kui baasklassi muutuja või meetod on privaatne - siis alamklassid sellele ligi ei saa. Public meetodi ja muutuja poole
saab pöörduda ükskõik kus kohast - seega päriluse korral see toimib ka. Lisaks vaatleme nüüd veel ühe direktiivi: protected. Protected
lubab juurdepääsu muutujatele ja meetoditele ainult klassist kus nad on defineeritud ning lisaks ka kõikidest temast tuletatud
alamklassidest.
Näide 6.3.3

 
7.1 Ülevaade
HTTP on suhteliselt lihtne tekstipõhine  protokoll  informatsiooni edastamiseks arvutivõrkudes. Nagu me juba teame, brauser ja
veebiserver suhtlevad omavahel HTTP (Hyper-Text  Transfer   Protocol ) protokolli abil. Teiste sõnadega HTTP on keel, mida räägivad
omavahel kliendi brauser ja veebiserver. HTTP on  päring -vastus  protokoll , kliendi brauser moodustab ja esitab serverile päringu ja
vastusena saab serverilt päritud faili.
Selleks, et vaadata täpsemalt, kuidas HTTP suhtlus toimub kasutame  Firebug  plugini  Firefox  brauseri jaoks.
Juhul, kui teie arvutis veel puudub Firefox brauser, siis on õige aeg seda installeerida. Nüüd lisame
brauserisse Firebug plugini (kasutame versiooni 1.3.2, sest versioonis 1.3.3 on mingi viga post parameetrite
näitamisel). Juhul, kui installeerimine õnnestus näete paremas alumises  nurgas  Firebug ikooni.  Firebugi
kasutatakse tihti javascripti ja css käitumise debugimiseks ning DOM struktuuri õiguse kontrollimiseks. Meie
aga hakkame seda praegu kasutama HTTP GET ja POST meetodite uurimiseks.
Klikkige Firebug ikooni peale ja menüüs valige Net → Enabled.
Avage näiteks  http://exact.ee lehe ja kui Firebug ei ole avatud klikkige selle ikooni peale ja valige  Net. See, mis teie praegu näete on
kõik päringud mis teie brauser on teinud selleks, et laadida ja peale seda nädata exact.ee lehe:
Päringuid võib ka sorteerida:
Valige HTML. Nüüd nimekirjas on ainuke päring, uurime seda põhjalikumalt. HTTP päring koosneb päringust, päistest ja andmetest.
Päringurida koosneb päringu tüübist, dokumendi URL-ist ja protokolli versioonist. Näiteks praegu päringureaks on GET  http://exact.ee
HTTP/1.1, päringureale järgenavad päised, mis lõpevad tühja  reaga  ja peale seda päringu andmed (neid saadetakse serverile ainult
POST päringu puhul, GET puhul parameetreid kirjutakse otse dokumendi URL-i):
Mõnede tähtsamate päisete  selgitused  (klient → server):
Host  - hosti nimi (exact.ee, google.com,  neti .ee ...)
User - Agent  - info brauseri ja opsüsteemi kohta
Accept  - meedia tüübid mis on aktsepteeritavad brauseri poolt
Accept- Language  - keeled, mis brauser eelistab
Accept-Charset - lehe charsetid, mis on eelistatud
HTTP vastus koosneb vastusest, päistest ja andmetest (dokumendist). Vastuses (struktuur: protokoll kood tekst) sisalduv kood näitab
kas päring õnnestus või mitte: HTTP/1.1 200 OK. Vastusele järgnevad päised, neid lõpetab samuti tühi rida ja peale seda lähevad
vastuse andmed. Mõnede tähtsamate päisete selgitused (server → klient):
Date  - aeg millal vastus oli  saadetud
Server - info serveri kohta
Last- Modified  - aeg millal päritud  resurss  oli viimati muudetud
Content- Length  - saadetud ressurssi suurus
Content-Type - ressurssi meedia tüüp
Kuna GET parameetreid kirjutatakse otse URL-i - parameetrite sümbolite arv on piiratud (erinevate brauserite ja serverite puhul
maksimaalne URL-i pikkus on erinev). GET parameetreid kirjutatakse URL-is peale küsimärki kujul
parameetri_nimi=parameetri_väärtus ning erinevaid parameetreid eraldatakse & märgi abil. GET parameetrite näide:
http://www.neti.ee/cgi-bin/otsing?query=ajax&src=web. Siin parameetriteks on  query ja src ning parameetrite väärtusteks vastavalt
ajax  ja web.
Nüüd avage  http://www.aleixcortadellas.com/main/ ja sisestage paremas ülemises nurgas otsingu aknas mingi sõna ja vajutage Enter .
Firebug  aknas  tuleb üks tab nimega POST juurde. Selles tabis näidetakse, mis parameetreid edastatakse serverile koos päistega päringu
andmete osas. Parameetrid on alati paar: parmaeetri nimi - väärtus. POST-iga saab edastada nii palju informatsiooni kui  soovite  (seda
piiratakse tavaliselt serveri konfiguratsiooni failis ja paljudel  juhtumitel  POST andmete suuruse  limiit  on suurem, kui GET puhul URL-i
pikkuse limiit) ning andmed pole nähtavad URL-is.
Lisalugemist
HTTP 1.1  spetsifikatsioon  (www) - inglise keeles
Firebug dokumentatsioon (www) - inglise keeles
 
7.2 GET
GET parameetrid on kättesaadavad PHP skriptis läbi globaalse $_GET massiivi. Massivi elementide võtmeteks on parameetrite nimed ja
väärtusteks vastavalt parameetrite väärtused. Lihtne näide: skript võtab URL-ist parameetrid param1 ja param2 ning väljastab nende
väärtused ekraanile.
Näide 7.2.1
http://localhost/index.php?param1=Hello¶m2=world
     param1: Hello
     param2: world
http://localhost/index.php?param1=yahoo
     param1:  yahoo
     param2:
Hästi tihti kasutakse GET parameetreid mingi info näitamiseks parameetri järgi. Näiteks uudiseid:
Näide 7.2.2
http://localhost/index.php
     Systems go for  Sunday  Shuttle  Discovery  launch
     Facebook Announces Facebook Connect for  iPhone
     Forget the Fail Whale:  Twitter  Jumps the  Shark
     iPhone firmware followup: the numbers
http://localhost/index.php?id=14
      Back  to the list
     Systems go for Sunday Shuttle Discovery launch
     Commander Lee Archambault is set to  lead  a  crew  of  seven  on the STS-119
      mission , which is  aimed  at installing the  fourth  and  final  set of  power -
     generating  solar  arrays to the ISS. The arrays will  provide  electricity
     to fully power  science  experiments and  support  the  station 's expanded
     crew in May.
Lisalugemist
HTTP 1.1 spetsifikatsioon (www) - inglise keeles
Firebug dokumentatsioon (www) - inglise keeles
 
7.3 Vormid
Juhul, kui soovite saada kasutaja käest mingi info saada - siis abiks on html vormid. Kasutaja saab sisestada informatsiooni teksti
lahtritesse (text, textarea), valida erinevaid väärtusi kontrollkastide (checkbox), raadionuppude ( radio ) ja  menüüde  ( select ) abil. Kõik
need elementid pannakse vormi sisse, mida on võimalik saata serverile kas GET või POST parameetritena. Vaatleme vormi elemendid
eraldi ja pärast kasutame neid vormi loomiseks.
Form
Vormi element ise, mis koondab elemendid, mis vormi sisse käivad. Vormi  tähtsamateks  atribuutideks on  method  ja  action .  Meetodiks
võib olla kas GET või POST - selle abil võib defineerida kuidas kasutaja poolt  sisestatud  info serverini jõuab (kas GET või POST abil).
Action  defineerib  URL-i millele saadetakse GET või POST päring. Näiteks järgmises vormis:
Näide 7.3.1
   ...
   ...
päringu saatmiseks kasutatakse POST meetodit ja andmeid saadetske skripti  http://localhost/comment.php. Vaikimisi meetod on GET ja
action on sama URL, kus asub vorm ise. Näiteks lehel  http://localhost/form.php asub vor m:
Näide 7.3.2
   ...
   ...
Vormi saatmisel kasutatakse GET päring ja skript, kuhu andmeid saadetakse on see sama  http://localhost/form.php .
Text
Teksti  lahter , mida kasutatakse peamiselt vaba teksti sisestamiseks. Peaaegu kõikide vormi elementide ühistägiks on  ning
elemendi tüüpi määrab type atribuut. Teksti lahtri atribuut on text. Teised olulised atribuudid on name (sama atribuut on kõikidel
vormi elementidel olemas, sest see on GET või POST parameetri nimi), value (väärtus, mis asub  lahtris , päringu saatmisel parameetri
väärtus), maxlength (maksimaalne sümbolite arv lahtris). All on toodud text input'i näited:
Näide 7.3.3
     
Tulemus
Näide 7.3.4
     
Tulemus
Password
Teksti lahter, mille  sümbolid  on peidetud kasutaja eest. Tihti kasutatakse  parooli  sisestamiseks:
Näide 7.3.5
     
Tulemus
Button
Tavaline  nupp , mis ei mängi vormis erilist rolli, vaid seda saab edukalt kasutada javascripti käivitamiseks. Atribuut value määrab nupu
teksti.
Näide 7.3.6
     
Tulemus
Näide 7.3.7
     
Tulemus
Checkbox
Konrollkast. Kui elemendi sees on olemas atribuut checked - siis kontrollkast on linnutatud, vastasel juhul kast on tühi. Name-value
paari edastatakse serverile GET või POST päringus vaid siis, kui kontrollkast on linnutatud, vastasel juhul seda ei tehta. Võib defineerida
ka atribuuti id (unikaalne  identifikaator ) selleks, et pärast panna  tägi, mis  viitab  vastavale input elemendile.
Näide 7.3.8
     
      Winter
     
      Spring
     
      Summer
     
      Autumn
Tulemus
Winter
Spring
Summer
Autumn
Radio
Raadionupp. Atribuut checked töötab nagu checkbox korral. Name-value paari edastatakse serverile GET või POST päringus vaid siis,
kui Raadionupp on valitud, vastasel juhul seda ei tehta. Atribuuti id võib ka kasulik olla. Selleks, et luua raadionuppude grupi - peab
gruppi kuuluvate raadionuppude nimed olema samad.
Näide 7.3.9
     
     Winter
     
     Spring
     

.PDF Laadi alla originaalfail 67 lk