Preprotsessor PHP

PHP ehk “PHP: Hypertext Preprocessor” on laialdaselt levinud vabavaraline skriptimiskeel, mis on paigutatav HTML’i sisseeriti. Hästi sobib veebiprogrammeerimiseks. Süntaks on C, Java ja Javascripti ning Perlile moodi. Kui oli eelnevaid kogemusi nende keeltega on PHP lihnte õppimisel. Peamine eesmärk on dünaamiliste veebilehtede kiire ja mugav kirjutamine. Kuid võimaldab ka ehitada keerulisi portaale ja graafilisi kasutajaliideseid.

PHP jookseb väga erinevatel platvormidel ja toetab väga suurt hulka andmebaase.

Abimaterjalid http://www.php.net, http://ee.php.net

1. PHP-s kasutatavad andmetüübid

PHP- s on 6 - andmetüüpi:

– Täisarv (integer) [32- bitine arv]

13 – kümnendkuju ei alga nulliga

015 – kaheksandkuju algab nulliga

0xD – kuueteistkümnendkuju algab 0x-ga

-19 – ka negatiivne täisarv on täisarv

– Reaalarv (double)

-123.456 – võib sisaldada punkti täis- ja murdosa eraldajana

123456e^-3 - 123456^-3 nn. Teaduslik tähistus

– String (string) e sõne

Sõne koosneb sümbolitest, eraldi sümbolitüüpi PHP-s ei ole. Erilised sümbolid varjestatakse langjoonega:

\n \r \t \\ \” \$ \0kaheksandkood \x16kood

Sõne piiritlemiseks on jutumärgid või ülakomad, millel on erinev semantika:

“muutujaasendusega sõne on jutumärkides, näit. \$PHP_SELF muutub väärtuseks $PHP_SELF” ‘siin sees tuleb ülakoma \’ varjestada langjoonega \\, aga muud asjad lähevad märk-märgilt’. Sõnede ühendamiseks on operaator punkt: sõne1.sõne2

– Boolean

– Massiivid

– Objektid

2. Muutujate kasutamine PHP-s

Tahtes andmeid vahepeal mälus hoida, tuleb kasutada muutujaid. Muutuja puhul antakse andmetele nimi (alljärgnevas näiteks s) ning edaspidi saab selle nime järgi taas sinna pandu kätte. Muutuja nime ees on dollarimärk $.

NB! Kui me räägime muutujate salvestamisest, siis see ei tähenda, et nad salvestatakse samamoodi, nagu tekstitöötlusprogramm salvestab dokumendi. Muutujad salvestatakse arvuti mällu ainult konkreetse PHP skripti töö ajaks. Järgmine kord, kui skript tööle läheb, algab kõik otsast peale.
Muutujat tähistatakse alati dollarimärgiga. Tema nimi peab algama alakriipsu või tähega ning võib(mitte esimese tähena) sisaldada numbreid. Muutujale väärtuse omistamine käib nii:
$muutuja_nimi='väärtus';
$teine_muutuja=333;
Kui muutujale omistatakse tekstiline väärtus, siis tuleb see panna ülakomade(või jutumärkide) vahele(põhimõtteliselt teatud juhtudel saab ka ilma, ent siis tasuks arvesse võtta, et kui mõni kogenud programmeerija seda näeb, hakkab ta karjuma :). Numbri puhul tavaliselt jutumärke ei panda, kuigi võib. Iga omistamislause lõpetab semikoolon.
PHP ei tee vahet muutujate tüüpidel(kas muutuja väärtuseks on tekst, number,...). Kõiki muutujaid võib omavahel liita, lahutada, võrrelda jne.

Nähtavuspiirkond võib olla lokaalne (muutuja on nähtav ühe funktsiooni piires, s.h. formaalsed parameetrid), globaalne (muutuja “surutakse funktsioonist välja” võtmesõna GLOBAL abil) või seisusäilitav (“poolglobaalne”, s.t. võtmesõnaga STATIC kirjeldatud muutujaid funktsioonist väljumisel ei kaotata, nende väärtus säilitatakse järgnevateks pöördumisteks).

Näide:

$kasutaja = ”Rummu Jüri”;

echo($kasutaja);

3. PHP muutujate nähtavus

Parameetreid võib edastada väärtuse või aadressi järgi

Vaikimisi kehtivad kõik muutujad oma plokis ning kõigis, mis sellesse kuuluvad (va. juhul kui funktsioon samanimelise defineerib)

$position = ”m”;

function change_pos() {

$position = ”b”;

}

change_pos();

echo(”$position”); // Trükib ”m”

Muutuja on võimalik defineerida globaalseks või viidata globaalsele, kasutades global võtmesõna:

$position = ”m”;

function change_pos() {

global $position; // ≡ $GLOBALS[”position”] = ”b”;

$position = ”b”;

}

change_pos();

echo(”$position”); // Trükib ”b”

Staatilised muutujad

– Aeg-ajalt osutub kasulikuks mingi funktsiooni sees tehtavaid toiminguid hoida selle funktsiooni muutujates

– Tavaliselt lokaalmuutujad kaotavad väärtuse kui funktsioonist väljutakse

function counter() {

$counter = 0; // nullime loenduri funtsiooni sisenedes

++$counter; // suurendame loenduri väärtust

}

– Selle vastu aitab static võtmesõna

function counter() {

static $counter = 0; // nullime loenduri esimesel funtsiooni sisenemisel

++$counter; // suurendame loenduri väärtust (igal f.-ni väljakutsel)

}

4. Muutujate tüüpide teisendamine PHP-s

Tüübisüsteem ei ole range, vajadusel lisatakse automaatseid tüübiteisendusi. Näit. sõne "9 muu jutt" on vajadusel täisarv 9 või sõne "3.14 korda" on vajadusel reaalarv 3.14 jne.

Saab lisada ilmutatud tüübiteisendusi:
(int) (integer) (real) (double) (float) (string) (array) (object)

PHP – Muutujad ja tüübimuundus

• Muutuja defineerimine

• Stringi konversioonid

– Kui string algab numbriga, siis saadakse selle väärtus

– Kui algab millegi muuga, saadakse tulemuseks 0

$ridu = 10;

$produkt = ”Pump”;

$hind = 24.00;

$saatekulud = 5.00;

$kokku = $hind + $saatekulud;

$str = ”222B Baker Street”;

$x =3 +$ str; // $x = 225, muutuja $str ise ei muutu

• Tüübimuundus vastavalt tüüpidele

• Sunnitud tüübimuundus

• Muutuja muutujad

$a = 1; // täisarv

$b = 1. 0; // reaalarv

$c = $a + $b; // tulemuseks reaalarv väärtusega 2.0

$d = $c + ”6th”; // saame reaalarvu väärtusega 8. 0

$a = 11.2; // reaalarv

$a = (int) $a; // täisarv väärtusega 11

$a = (double) $a; // reaalarv väärtusega 11.0

$b = (string) $a; // string väärtusega ”11”

$field = ”ProductID”;

$$ field = ”432BB”;

echo($ ProductID); // Trükib 432BB

echo($$ field); // Trükib 432BB

5. Omistamisoperaator PHP-s

• Omistusoperaator

Operaator Tähendus

= Omistamine $b = 5;

• Omistamisoperaatorite lühivariandid

Operaator Tähendus

$h += $ i $h = $h + $i

$h -= $ i $h = $h - $i

$h* = $ i $h = $h * $i

$h /= $ i $h = $h / $i

$h %= $ i $h = $h % $i

$h &= $ i $h = $h & $i

$h |= $ i $h = $h | $i

$h ^= $ i $h = $h ^ $i

$h .= $ i $h = $h . $i

$h >>= $ i $h = $h >> $i

$h <<= $ i $h = $h << $i

$h ++ $h = $h +1

$h -- $h = $h –1

6. Konstandid ja nende kasutamine PHP-s

PHP defineerib suurt hulka konstante ja see moodustab suure nn mehhanismi, mille abil saab ka lisakonstante defineerida. Konstandid sarnanevad paljuski muutujatega, ainus vahe on see, et kostante defineeritakse define() funktsioonidega. define(“identifikaator”, väärtus);

Konstandi olemasolu saab testida:

define(” COMPANY”, ”Commodore”);

define(” KOLLANE”, ”# FFFF00”);

define(” VERSION”, 3);

define(” NL”, ”< BR>\ n”);

if (defined(” KOLLANE”)) {

echo(”< BODY BGCOLOR=” . KOLLANE . ”>\ n”);

}

echo( COMPANY .” ehitas kunagi arvuteid” . NL);

Sisseehitatud konstandid TRUE FALSE

Globaalne informatsioon

PHP_ VERSION

PHP_ OS

Faili parsimine

__ FILE__ Hetkel parsitava faili nimi

__ LINE__ Hetkel parsitava rea number

Veakoodid

E_ ERROR

E_ WARNING

E_ PARSE

E_ NOTICE

Kui sul leidub kuskil konfiguratsioonifailis muutujad (näiteks paroolid, värvid, tabelite nimed jne), mida sa kunagi ei muuda, tuleks kasutada konstante. Konstantide puhul on kindel, et keegi ei saa neid üle kirjutada.

define(‘parool’, ‘admin’); //defineerime parooli

define(‘parool’, ‘uusadmin’); //proovime uuesti defineerida (muuta)

$parool=’kasutaja’; //kirjutame muutujasse

echo constant(‘parool’); //admin

echo PAROOL; //admin

echo ‘<br>’;

echo $parool; //kasutaja

Nagu näha, defineerisime ühte konstanti kaks korda, kuid see teine kord ei mõjunud ning väljastati defineeritud väärtus, kuna tegu on konstantidega ehk püsiväärtustega. Samuti näeme siit, et muutujad ja konstandid ei lähe omavahel segi.

7. Manipuleerimine stringidega PHP-s.

<?php
$str_1 = 'Ma alustan stringi ülakomaga';
$str_2 = " Ma alustan stringi jutumärkidega";
?>

Kõige lihtsam on stringi määrata ülakomadega. Pannes srtingi jutumärkidesse lubab PHP-l aru saada spetsiaal märkidest:

\n new line

\r return (rea algusesse)

\t horisontal tabulatsioon

\\ sümbol \

\$ dollari märk

\” jutumärk

\[0-7] {1,3} kaheksand arvu regulaarväljund

\x[0-9A-FA-f] {1,2} 16-nd arvu regulaarväljund

8. Spetsiaalsümbolid PHP-s ja nende kasutamine.

Osadel märkidel on spetsiaalne tähendus

• URL koodi kasutatakse vältimaks nende erisümbolite

interpreteerimist – näiteks tühik väärtuspaari sees

peab olema eraldatud ’+ ’- ga, mujal URL- is %20- ga

Märk Tähendus URL kood (hex)

# Dokumendi osale viitamine %23

% Erimärkide kodeerimine %25

& Vormi nimi/ väärtus paaride %26

eristamine

+ Tühik väärtuse sees %2B

/ Kataloogi tee eraldaja %2F

= Nime ja selle väärtuse sidumine %3D

? Päringustringi alguse tähistus %3F

9. Ülakomade(´ ) ja jutumärkide kasutamise erinevused PHP-s

Ülakomade ja jutumärkide vahel olevad stringid annavad erineva tulemuse. Jutumärgid loevad srtingi muutujatena, aga ülakoma kui osa stringist

<?php
$num = 9;
echo 'Väljasta number $num';
// kuvab "väljasta number $num" ekraanile
echo "Display the number $num";
// kuvab "välajasta number 9" ekraanile
?>
Kuna ülakoma scriptid töötavad kiiremini kui jutumärkide omad tuleks neid kasutada ainult kui sa tahad kasutada muutujaid stringis.
On soovitatav kasutada selliseid stringe nagu alltoodud tabelis kui sa kasutad keerulisi või ka lihtsaid muutujaid.

<?php
$str_1 = 'See on j';
$str_2 = 'ärjekordne igav';
$str_3 = 'stringi näide';
echo $str_1.$str_2. " " .$str_3. ".";
?>

10. Ühemõõtmeliste massiivide kasutamine PHP-s.

Massiivi tüüpi muutujat märgitakse sarnaselt tavalise muutuja nimega, kuid tema kasutamisel peab arvestama, et tegu on massiiviga. Näiteks defineerime massiivi ja trükime välja selle elemendid:

$mass=array(“Priit”, “Jaan”, “Memm”, “Kana”, “Ivo”);

$a=current($mass);

do {

print “$a”;

} while ($a=next($mass));

Funktsioon current tagastab massiivi esimese elemendi väärtuse; next järgmise elemendi väärtuse.

Kõik massiivi elemendid on ühte tüüpi (öeldakse ka, et massiiv on sedasama tüüpi). Massiivi elemendile viidatakse (diskreetset tüüpi) indeksi abil.

Massiiv ei tarvitse olla ühemõõtmeline. Indeksite arv massiivikirjelduses näitab, mitmemõõtmelise massiiviga on tegemist.

11. Assotsiatiivsed massiivid

Tavalises massiivis saab üksikute elementide poole pöörduda kasutades elemendi indeksit, mis on täisarvuline ja algab nullist. Defineerime massiivi:

$massiiv[0]=”Jaan”;

$massiiv[1]=”Peeter”;

$massiiv[2]=”Laur”;

Näiteks pöördume teise elemendi poole:

Print “$massiiv[1]”;

Assotsiatiivse massiivi puhul võib see indeks olla ka tekstiline. Assotsiatiivse massiivi puhul nimetatakse indeksit võtmeks ja seda millega võti on seotud väärtuseks. Defineerime massiivi:

$inimesed[“Priit”]=”21”;

$inimesed[“Jaan”]=”54”;

ning pöördume teise elemendi poole:

print “$inimesed[“Jaan”];

Tulemusena tagastatakse väärtus 54.

Assotsiatiivsus tähendab, et andmed on sisuliselt paarikaupa seotud: näiteks nimi ja vanus. Esitame terviklikuma näite:

$inimesed=array(“Priit”=>”21”, “Jaan”=>”54”, “Memm”=>”67”, “Kana”=>”82”, “Ivo”=>”14”);

while (list($nimi, $vanus)=each($inimesed))

{

print “$nimi $vanus<br>”;

}

Pikema massiivi korral võib selle sisu ulatuda üle mitme rea tingimusel, et viimase rea lõpetab semikoolon (;) nagu näites.

Esimesel kahel real defineeritakse massiiv $inimesed. Seejärel kasutatakse while kordust massiivi väärtuste väljatrükkimiseks. each tagastab iga kord kaks väärtust, mis omistatakse käsuga list muutujaile $nimi ja $vanus.

Teisendame tavalise massiivi assotsiatiivseks:

$inimesed=array(“Priit”, “21”, “Jaan”, “54”, “Memm”, “67”, “Kana”, “82”, “Ivo”, “14”);

for ($i=0; $i<sizeof($inimesed); $i+=2) {

$ass_mass[$inimesed[$i]]=$inimesed[$i+1];

}

while (list($nimi, $vanus)=each($ass_mass))

{

print “$nimi $vanus”;

}

Käsuga array_keys, saab assotsiatiivsest massiivist kätte kõik võtmed, tagastatakse tavaline massiiv võtmenimelisi väärtusi:

$inimesed=array(“Priit”=>”21”, “Jaan”=>”54”, “Memm”=>”67”, “Kana”=>”82”, “Ivo”=>”14”);

$votmed=array_keys($inimesed);

for($i=0; $i<sizeof($votmed); $i++) {

print “$votmed[$i]<br>”;

}

12. PHP laused, operandid ja operaatorid

Operaatorite abil saad kontrollida ja käsutada väärtusi(nt muutujate väärtusi). Põhimõtteliselt on neil programmeerimises samasugune roll, nagu liitmis-, lahutamis-, korrutamis-, jagamis- ja muudel märkidel matemaatikas. Tegelikult väga paljud operaatorid ongi igaühele tuntud juba algkoolimatemaatikast - siis küll teiste nimede all. Programmeerimises nimetatakse neid operaatoriteks.

Operaator	Assotsiatiivsus	Sihtpunkt
( )	-	Prioriteedi muutus
new	-	Objekti eksemplari loomine
!~	P	Loogiline eitus, bit haaval eitus
++--	P	Increment, decrement
@	P	Vigade maskeerimine
/ * %	V	Jagamine, korrutamine, jäägi arvutus
+ - .	V	Liitmine, lahutamine, konkatentsioon
<< >>	V	Bit haaval nihe vasakule, paremale
< <= > >=	-	Väiksem, väiksem võrdne, suurem, suurem võrdne
== != === <>	-	Võrdne, ei ole võrdne, identne, ei ole võrdne
& ^ \|	V	Bit haaval AND, XOR, OR
&& \|\|	V	Loogiline AND, OR
?:	P	Ternar operaator
= += *= /= .= %= &= \|= ^= <<= >>=		Omistamisoperaatorid

Ternar operaatorit kasutatakse siis kui soovitakse tingimus lühemalt ja lause sisse kirja panna. Koosneb kolmest osast: esimeses on tingimus, teises käitumine/vastus tingimuse tõese väärtuse puhul, kolmandas väära väärtuse puhul. Tingimust eraldab küsimärk, vastuseid koolon.

$marivanus=13;

$jukuvanus=14;

echo “Mari “. (($marivanus<$jukuvanus) ? “on” : “pole”). “ noorem kui Juku”;

13. Operaatorite prioriteet PHP-s

( ) – prioriteedi muutus

14. Matemaatilised tehted PHP-s.

/ * %	V	Jagamine, korrutamine, jäägi arvutus
+ - .	V	Liitmine, lahutamine, konkatentsioon

+ - / *(liitmine, lahutamine, jagamine, korrutamine). Tavaline matemaatika. Tehteid saab teha nii numbritega kui muutujatega, samuti mõlematega läbisegi.
$a=5+4;
$c=$a-8;
$d=55/$b;
$e=$a*$d;

Liitmisoperaatorit kasutatakse nt kahe stringi liitmiseks.

$esimene='Tere ';
$teine='ise ';
$kolmas=$esimene.$teine;
//kokku saime $kolmas väärtuseks "Tere ise "

15. Omistamise operaator PHP-s.

= += *= /= .= %= &= |= ^= <<= >>=

Omistamisoperaatorid

Stringide(teksti) puhul kasutatakse tavalist omistamisoperaatorit(võrdusmärk) ning liitvat omistamisoperaatorit(punkt ja võrdusmärk).
Juurdeliitmisoperaatorit kasutatakse näiteks stringile uue lõigu liitmiseks.

Tavaline: $a='Pipar';
Nüüd on $a väärtuseks "Pipar"
Liitev: $a.='kook';
Nüüd on $a väärtuseks "Piparkook"

Arvude puhul pruugitakse samuti omistamis- ja liitvat omistamisoperaatorit, ent viimatinimetatu on teise väljanägemisega.
Tavaline: $a=4;
Praegu on $a väärtuseks 4.
Liitev: $a+=5;
Nüüd on $a väärtuseks 9.
Liitva näite oleks võinud kirjutada ka nii, mis on täpselt sama:
$a=$a+5;

16. Loogiliste tehted (operaatorid) PHP-s.
! - ei
&& - ning
|| - või

Eituse kasutamine, kasutatakse funktsioonide või muutujate ees.
//kui muutujal $tekst ei ole pikkust
if(!strlen($tekst))
{
echo 'Teksti ei ole';
}

//kui muutujal $tekst ei ole pikkust
//[b]ning[/b] muutujal $tekst2 on pikkus
if(!strlen($tekst) && strlen($tekst2))
{
echo 'Teksti ei ole';
}

//kui muutujal $tekst ei ole pikkust
//või muutujal $tekst2 on pikkus
if(!strlen($tekst) || strlen($tekst2))
{
echo 'Teksti ei ole';
}

17. Võrdlemise tehted (operaatorid) PHP-s

< <= > >=	-	Väiksem, väiksem võrdne, suurem, suurem võrdne
== != === <>	-	Võrdne, ei ole võrdne, identne, ei ole võrdne

Tähtsaimad võrdlemisoperaatorid on:
> suurem
< väiksem
!= ei ole võrdne
== on võrdne
>= on suurem või võrdne
<= on väiksem või võrdne
Pane tähele, et võrdelisuse teadasaamiseks ei kasutata võrdusmärki, vaid kahekordset võrdusmärki.

18. Opereerimine bittidega PHP-s.

!~	P	Loogiline eitus, bit haaval eitus
<< >>	V	Bit haaval nihe vasakule, paremale
& ^ \|	V	Bit haaval AND, XOR, OR

19. IF ELSE operaator PHP-s.

if()else{}
if-else on kõige tavalisem tingimuslause, mis tähendab: kui midagi on nii, siis tee seda(vastasel juhul tee midagi muud).

If, else ja elseif on ühed enimkasutatavad asjad PHP skriptides. Nendega saab määrata, mida mis tingimustel tehakse. Näiteks kui stringi $str väärtus on 8, siis väljastatakse tekst "korras". Aga kui $str väärtus on 23, siis väljastatakse "võiks parem olla". Kui $str on 52, väljastatakse "enam-vähem". Vastasel juhul (kui $str ei ole ei 8 ega 23) väljastatakse "täiesti vale".

if(väljend) {

blokk

}

else {

blokk2

}

if(väljend1) {blokk1}

else_if(väljend2) {blokk2}

…

else_if(väljend3) {blokk3}

else {blokk4}

Näide:

if ($food==”Pasta”){

if($cooking_weight<200) {

print “This is enough pasta (<200g) for 12 people”;

}

else if($cooking_weight <500) {

print “That’s a lot of pasta. Having a party perhaps?”;

}

else {

print “Whoo! Who are you cooking for, a football team?”;

}

Tasub meelde jätta, et if'i võib kasutada ka ilma else ja elseif osata või ainult koos ühega nendest, samuti võib lauses elseif osasid olla mitu.

20. WHILE operaator PHP-s.

While lause tähendus on lihtne. See ütleb PHP-le et täide viia tsükli kordus, niikaua kui while avaldis muutub TÕESEKS. Avaldise väärtust kontrollitakse iga kord tsükli alguses. Nii ka kui see väärtus muutub tsükli kordamise käigus, korda ei katke kuni vastastikmõju toimumiseni (iga kord PHP loeb lauseid tsüklites üheks vastasmõjuks). Mõnikord kui while avaldis väärtustatakse VALEKS väga alguses, korduses olevaid lauseid ei korrata mitte ühtegi korda.
Nagu if lause puhulgi sa võid grupeerida arvukaid lauseid sama while tsükli kestel ümbritsedes gruppi lauseid loogeliste sulgudega.

while(väljend) {

blokk

}

Näide:

$n=5;

$ncopy=$n;

$factorial=1;

while($n>0):

$factorial=$n*$factorial;

$n--;

end while;

print “The factorial of $ncopy is $factorial”;

Järgnevad näidised on samad, mõlemad väljastavad numbrid 1-10-ni:

/* näidis 1 */
$i = 1;
while ($i <= 10) {
print $i++;
}

/* näidis 2 */
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;

21. DO WHILE operaator PHP-s

do … while konstruktsioon on sarnane while’ga erinedes selle poolest, et tingimust kontrollitakse peale ploki täitmist. Seega täidetakse plokki vähemalt üks kord. Sellist kordust läheb enamasti vaja, kui samm tuleb ühel korral igal juhul läbida (näiteks andmete küsimine) ning tegevust läheb kordamisele vaid juhul, kui esimesel korral midagi nihu läks.

do {

blokk

} while(väljend);

Näiteks trükime välja arvud ühest viieni:

$i=0;

do {

print $i;

} while ($i>0);

22. FOREACH operaator PHP-s.

Foreach konstruktsioon võimaldab mugavalt täita plokis olevaid lauseid iga massiivi elemendi jaoks.

foreach(massiiv as $element) {

blokk

}

for …(massiiv as $võti=>$element) {

blokk

}

Näiteks väärtustame viie-elemendilise massiivi $m ning trükime selle elemendid välja:

$m=array(“Jaan”, “Peeter”, “Marta”, “Laura”);

$I=1;

foreach($m as $element) {

print $I++.”. $element”;

}

Näide2:

$menu = array (“pasta”, “steak”, “potatoes”, “fish”, “fries”);

foreach ($menu as $item) {

print “$item <br>”;

}

$wine_inventory = arrray {

“merlot” => 15

“zinfandel” => 17

“sauvingon” => 32

}

foreach (wine_inventory as $i => $item_count) {

print “item_count bottles of $i remaining <br>”;

}

23. SWITCH operaator PHP-s.

Switch käsku võib võrrelda käsuga if, kuigi if käsuga on rohkem võimalusi, samas koormab switch enamus juhtudel vähem serveriressurssi, kui if. Switch’iga saab vahetada mingi jupi koodis teise samalaadse koodijupi vastu.

switch (lause/muutuja) {

case (tingimus/väärtus):

blok

case (tingimus/väärtus):

blok

.......

default:

}

Näide:

$value=0,4;

switch($value):

case(0,4):

print “value is 0,4<br>”;

case(0,6):

print “value is 0,6<br>”; break;

case(0,3):

print “value is 0,3<br>”; break;

default:

print “You didn’t choose a value!”; break;

endswitch;

Võtame ette <style> käsuga tabeli värvi muutmise:

switch($id)
{
case style1:
echo"<style> table{background-color: black;}";
break;
case style2:
echo"<style> table{background-color: red;}";
break;
case style3:
echo"<style> table{background-color: green;}";
break;
default:
echo"<style> table{background-color: white;}";
}

24. BREAK ja CONTINUE operaator PHP-s.

Break lõpetab switchi ahela täitmise (tegelikult saab temaga lõpetada ka teisi tsükleid nt for, while..). Kui me seda ei paneks, leiaks switch küll õige koha, kuid ei lõpetaks tööd ja täidaks ka kõik endast allapoole jäävad tingimused hoolimata sellest, et need tõesed ei ole. Break võib olla ka numbrilise väärtusega, mis näitab katkestatavate funktsioonide arvu.

$arr = array ('yks', 'kaks', 'kolm', 'stopp', 'neli');
while (list ( , $val) = each ($arr)) {
    if ($val == 'stopp') {
        break;  /* Siia saab ka 'break 1;' kirjutada, kuna see võrdub 'break;' käsuga. */
    }
    echo "$val<br>\n";

/* Valikuliste argumentide kasutamine. */
$i = 0;
    while (++$i) {
        switch ($i) {
            case 5:
                echo "Viie puhul<br>\n";
                break 1;  /* Lõpetab ainult switch'i. */
            case 10:
                echo "Kümne puhul; väljun<br>\n";
                break 2;  /* switch ja while lõpetamine. */
            default:
                break;
    }
}

continue n;

$prime_counter=0;

$boundary=558;

for($i=0;$i<=$boundary;$i++):

if(!is_prime($i));:

continue;

end if;

$prime_counter++;

end for;

continue töötab:
do
while
switch
for
foreach

continue is used within looping structures to skip the rest of the current loop iteration and continue execution at the beginning of the next iteration.

continue accepts an optional numeric argument which tells it how many levels of enclosing loops it should skip to the end of.

25. Funktsioonide mõiste ja kasutamise reeglid PHP-s.

Funktsioonid on esimene samm koodi korduvkasutuseks. Kui sul tuleb teha samas koodis mitu korda ühte ja sama asja, siis on selle jaoks juba mõttekas funktsioon kirjutada ning iga kord see toiming läbi funktsiooni teostada. Teine aspekt on loomulikult see, et sa saad samu funktsioone ju väga edukalt erinevates projektides kasutada: nt teed eraldi faili MySql funktsioonidega, kus on funktsioonid ühenduse loomiseks, päringu esitamiseks jm vajaliku jaoks. Nii säästad iga kord hulga aega, kui ei pea mysql päringu tegemiseks kogu kraami otsast peale kirjutama, vaid lisad lihtsalt funktsioonifaili: require_once(’mysql_functions.php’);

Funktsiooni valmistamiseks tuleb teada, mitut elementi sul selles on vaja kasutada: function funktsiooninimi($element1, $element2, $element3, $element4) {}

Funktsiooni sisu peab olema alati looksulgude vahel, { alustab ja } lõpetab funktsiooni.

Funktsiooni nimeks võib olla mistahes tähtede-numbrite jada, kuid kasutada ei tohi tühikuid ja enamikke sümboleid. Ei soovita kasutada ka täpitähti. Sümbolitest võib kasutada _ ehk alakriipsu. Funktsioonil võib elemente olla kuitahes palju, kuid enamikel juhul läheb tarvis vaid mõnda elementi. Funktsiooninimi ei tohi alata numbriga ja ei tohi kattuda PHP enda funktsiooninimedega. Funktsiooninimed on tõstutundetud – st kala() ja KaLa() kutsuvad välja sama funktsiooni.

Funktsiooni tegemisel pole elementide nimetus tähtis, sest seda kasutatakse ainult funktsioonisiseselt. Funktsiooni elementide nimetused pole seotud funktsiooniväliste muutujatega.

Funktsioonide tulemus tuleb ka väljastada. See, mis funktsiooni sees tehakse, pole tähtis väljaspool toimuvale. Väljastamiseks tuleb kasutada sellist juppi: return $str;

26. Funktsiooni tagastatav väärtus ja ploki mõiste PHP-s.

Funktsioonid võivad tagastada numbreid, stringe, tõeväärtuseid (true, false). Tagastada saab ka liste ja massiive. Näiteks funktsioon, mis vähendab talle antud stringi ühe tähe võrra ja tagastab stringi:

Näide 1:

<?php

function miinus($string) {

$string=substr($string,0,-1);

return $string;

}

echo miinus(’jaanalind’);

Seekord ei ütle funktsioon ise midagi, vaid tagastab väärtuse ning selelga võime teha, mida soovime, näites echo’sime selle, aga seda võib kasutada ka näiteks muutuja väärtustamiseks : $lyhike=miinus(’jaanalind’);

Näide 2:

$price=1000;
$tax= .06;
function calculate_cost($tax,$price) {
            $sales_tax=$tax;
            return $price+($price*$sales_tax);
            }
$total_cost=calculate_cost($tax,$price);
$total_cost=round($total_cost, 2);
Print "Total cost: ".$total_cost ;

27. PHP-le juurdeliidetavad failid ja funktsioonid. (Include, Link)

Põhierinevus include() ja require() vahel seisneb selles, et include()'el ei ole fataalset mõju skripti tööle. See tähendab, et kui faili, mida sooviti lisada, ei õnnestunud lisada, siis PHP jätkab ülejäänud skripti parsimist. Kui aga require() puhul ei suudeta vajalikku faili leida, siis skript katkestab töö.

Include toob etteantud failist välja väärtused mida tahame kasutada. Näide:

vars.php

<?php

$värv=’roheline’;

$puuvili=’õun’;

test.php

echo ”$värv $puuvili”; // ei too midagi

include ’vars.php’;

echo ”$värv $puuvili”; // roheline õun

Kui kasutada include’i funktsiooni sees siis töötab see ka ainult funktsiooni piires! Näide:

<?php

function foo()

{

global $color;

include 'vars.php';

echo "A $color $fruit";

}

foo(); // A green apple

echo "A $color $fruit"; // A green

Kui include’i kasutada mingi tingimuse sees siis peab selle panema bloki vahele. Näide:

VALE: if($tingimus) ÕIGE if($tingimus) {

include $file; include $file;

else } else {

include $file2; include $file2;

}

Failide avamisega PHP’s tuleb olla väga ettevaatlik. Kunagi ei tohi avatava faili nime edasi anda url real muutuja kaudu. Nt url: index.php?f=kala (include($f);) Nõnda võib iga suvaline tegelane vaadata iga suvalist faili, mis kuskil kataloogis leidub. Ettevaatlik tasub olla isegi siis, kui defineerid lisaks ka lühendi: include($f.’.php’); Sest ehk on kuskil kogemata fail nimega mysql.php, mis sisaldab nt MySql kasutajanime ja salasõna, mille sattumine võõrastesse kätesse on ebasoovitav. Üheks lahendustest on Switchi kasutamine:

switch($f) {

case slash:

include(’slash.php’);

break;

case dot:

include(’dot.php’);

break;

default:

include(’ava.php’);

}

Nii saab avada ainult switch tsüklis defineeritud faile. Ära kasuta skriptide includimiseks mõeldud funktsioone url’ide avamiseks, kui sa pole 101% kindel, et seda muutjat keegi muuta ei saa.

Teine lahendus:

<?php

if ($a==’tooted’) include(’tooted.php’);

elseif ($a==’teenused’) include(’teenused.php’);

elseif ($a==’hinnakiri’) include(’hinnakiri.php’);

elseif ($a==’kontakt’) include(’kontakt.php’);

else echo ’URL on vigane’;

Siin lihtsalt ütleme ükshaaval ette, mida võib ja mida ei või lubada.

Kolmas võimalus:

<?php

$lubatud=array(’tooted’, ’teenused’, ’hinnakiri’, ’kontakt’);

if (in_array($a, $lubatud)) include ($a.’.php’);

else echo ’URL on vigane’;

Siin anname massiivi (array) sisse kõik A väärtused, mis on lubatud. Seejärel kontrollitakse, ja kui vastav A on lubatud, siis alles inkluuditakse.

link() tekitab lingi. Tagastab TRUE õnnestumisel ja FALSE nurjumisel.

28. Matemaatilised funktsioonid PHP-s.

sin – siinus sin() väljastab "arg" parameetri siinuses. "Arg" parameeter peab olema radiaanides.

<?php
echo sin(60); // väljastus on -0.30481062110222
?>

asin – arkussiinus Väljastab arg arkussiinuse radiaanides
a==sin(asin(a))

cos – koosinus väljastab "arg" parameetri koosinuses. "Arg" parameeter peab olema radiaanides.

<?php
echo cos(20); // väljastus on 0.40808206181339
?>

acos – arkuskoosinus Väljastab argumendi arkuskoosinuse radiaanides.

tan – tangens väljastab "arg" parameetri tangenses. "Arg" peab olema radiaanides.

<?php
echo tan(30); // väljastus on -6.4053311966463
?>

atan – arkustangens Väljastab arg väärtuse arkustakngensi radiaanides vahemikus (-¶/2 ; ¶/2].
a==tan(atan(a))

deg2rad - This function converts number from degrees to the radian equivalent.

<?php
echo deg2rad(45); // 0.785398163397
var_dump(deg2rad(45) === M_PI_4); // bool(true)
?>

Kiirem võimalus: $radians = ( $degrees *pi() ) / 180

rad2deg - This function converts number from radian to degrees.

<?php
echo rad2deg(M_PI_4); // 45
?>

sqrt – ruutjuur - Leiab $mingist arvust ruutjuure.
Näiteks on sul teada, et täisnurkse kolmnurga 1 kaatet on 3 ja teine 4 ühiku pikkune.
$kaatet1=3;
$kaatet2=4;
//Hüpotenuusi leidmiseks tuleb teatavasti kaatetite ruudud liita ja
//summast võtta ruutjuur:
$summa=($kaatet1*$kaatet1)+($kaatet2*$kaatet2);
$hypotenuus=sqrt($summa);
print $hypotenuus;
ja vastuseks tulebki 5. :)

abs -- Absoluutne väärtus Absoluutväärtuse funktsioon. Sisendiks on üks argument (arv) ja tagastatakse sisendargument ise kui sisendarv on mittenegatiivne ning argumendi vastandväärtus, kui sisendarv on negatiivne. Kui alus numbri tüüp on float, siis see tuleb ka float, muidu on see täisarv.
$abs = abs(-4.2); // $abs = 4.2; (topelt/float)
$abs2 = abs(5); // $abs2 = 5; (täisarv)
$abs3 = abs(-5); // $abs3 = 5; (täisarv)

ceil -- funktsioonide ülespoole ümardamine
Väljastab suurima numbri ümardades ülespoole parameetrit number (kui vaja). Väljastatav ceil() väärtus on ikka reaalarv nagu ka reaalarvu väärtuse ulatus on tavaliselt suurem kui täisarv.

$viis = ceil(4.3); // $viis = 5.0;
$kymme = ceil(9.999); // $kymme = 10.0;
$muutuja = ceil(10.000);

29. Rekursiivsed funktsioonid PHP-s.

Rekursioon tähendab seda, et funktsioon kutsub iseennast välja. Kasuks tuleb see näiteks mõne rekursiivsust nõudva ülesande (menüü joonistamine, mõned arvutusülesanded jne) lahendamisel.

Võtame aluseks suhteliselt mõttetu funktsiooni jaanalinnust ja kahandame seda sõna niikaua, kuni järel on ainult üksainus täht:

funciton miinus($str) {

global $lind; //globaalne selleks, et oleks kasutatav iga kord, kui funktsiooni välja kutsume

$str=substr($str, 0, -1); //$str on üks täht väiksem, kui etteantud string

$lind.=’<br />’.$str; //lisame muutujale str’i osa

if(strlen($str)>1) //kui $str on suurem kui 1 tähemärk, saadame uuele ringile

{

miinus($str);

}

$lind=’jaanalind’;

miinus($lind);

echo $lind;

Põhiline asi rekursiivsete funktsioonide juures on see, et nad peavad oma töö mingil hetkel ka ära lõpetama, muidu satuksid nad lõpmatusse tsüklisse. Selle saavutamiseks on meie “jaanalinnufunktsioonis” kasutusel selline lõik: if(strlen($str)>1) ehk funktsioon kutsub ennast välja ainult seni, kuni järelejäänud string on veel suurem kui 1 tähemärk. Praktikas võiks rekursiivset funktsiooni kasutada näiteks menüü joonistamisel.

Näide2: arvutab 10 arvu summa

<?php

function summ($count){

if ($count!=0)

return $count + summ($count –1);

}

$n = 10;

$s = summ($n);

print “$n arvu summa = $s”;

30. Vormide töötlemise põhimõte. (_GET, _POST)

PHP's on olemas globaalsed, PHP enda poolt paika pandud muutujad, tähtsaimad neist on on $_GET, $_POST ja $_SELF.

$_GET muutuja saadakse GET-päringus olevatest argumentidest ehk eesti keeles: GET päringu teed sa iga kord, kui tipid brauserisse internetiaadressi. Kui veebiaadress on nt www.php.ee/222/?varv=valge&taevas=sinine, siis GET päringust saadavad muutujad on $_GET['varv'](väärtusega "valge") ja $_GET['taevas'](väärtusega "sinine"). Kui sa ise oleksid pidanud neile väärtuse andma, pidanuks sa kirjutama:
$_GET['varv']='valge';
$_GET['taevas']='sinine';
Aga PHP tegi seda juba sinu eest, nagu ta teeb kõigi aadressirealt saadud muutujatega.

POST päring seevastu toimub iga kord, kui kasutaja täidab veebilehel mõne tavalise vormi(nt ) ning selles olevad muutujad ei ilmu aadressiribale(ehk kui vormi postitamismeetod on POST, sellest täpsemalt hilisemates artiklites). Nt kui sul on vormis lahter nimega "nimi", siis lehe jaoks, kuhu sa satud peale vormi täitmist, on automaatselt kättesaadav muutuja $_POST['nimi'].

Lisaks kasutatakse suhteliselt palju ka $_SELF muutujat, mille väärtuseks on lehekülje relatiivne aadress ilma GET päringu muutujateta, nt sellise päringu www.php.ee/222/index.php?varv=valge&taevas=sinine korral on $_SELF väärtuseks "/222/index.php". $_SELF on kasulik näiteks siis, kui sama PHP koodi kasutatakse korraga mitmes eri failis ning on vaja teada selle faili nime.

Näide:

Name – muutuja nimi

Size – ekraanil nähtava kasti laius

Maxlenght – muutuja maksimaalne pikkus

<input type = “radio” name = “lyliti” value = “16”>Kuusteist<BR>

Kõige tähtsamad näitajad on muutuja nimi NAME ja muutuja väärtus VALUE – tavaliselt mingi string.