Lehekülje Php lähteteksti vaatamine

===Sissejuhatus===

PHPd kasutatakse dünaamiliste veebilehtede loomiseks. PHP töötab veebiserveris ning väljastab tavalist HTML teksti. PHPd võib näiteks kasutada selleks, et vahendada andmebaasi läbi veebi.

Andmebaasi kasutavate skriptide kirjutamisel tuleks arvestada järgmist

* andmebaasipäringud tuleb sooritada võimalikult korrektselt, näiteks selliselt, et andmete sorteerimine ja filtreerimine toimub SQLi vahenditega, mitte hiljem skriptis
* sisestades andmebaasi uusi andmeid või muutes olemasolevaid, kontrollige skriptis eelnevat nende sobivust, näiteks, et poleks lubatud sisestada arvulisse andmevälja teksti 

===PHP skript===

PHP skripti kood kirjutatakse <?php ja ?> märkide vahele. Faili laiendiks peab olema .php, vastasel juhul veebiserver PHP kood ei töötle. Seetõttu võidakse lehel kuvada (osaliselt) php koodi, mis seal tegelikult olema ei peaks.

Oluline on teada, et peale lehe genereerimist pole võimalik PHP skripti lähtekoodis näha. PHP on vaid vahend lehe genereerimiseks!

Näide: php.php

<source lang="php">
<html>
<body>
<h1><?php echo "Tere päevast!"; ?></h1>
<p>
<?php 
  /* see on kommentaar, mida PHP mootor ignoreerib */
  echo "Mina olen PHP skript!"; 
?>
</p>
</body>
</html>
</source>

...on samaväärne HTML koodina...

<source lang="html4strict">
<html>
<body>
<h1>Tere päevast!</h1>
<p>Mina olen PHP skritp.</p>
</body>
</html>
</source>

Brauser kuvab ekraanile järneva:

'''Tere päevast!'''
Mina olen PHP skritp.

Veebiserver kävitab <?php ja ?> märkide vahel oleva PHP skripti ning asendab selle tekkinud väljundiga. Et PHP tekitaks mingi väljundi, on vaja see ekraanile tuua käsuga echo. 

PHP käsud peavad lõppema semikooloniga (;) nagu

<source lang="php">
echo "Tere päevast!";
</source>

PHP skripti sisse saab kirjutada kommentaare. Näiteks:

<source lang="php">
/* see on kommentaar,
mida PHP mootor ignoreerib... */
</source>

või

<source lang="php">
// ühe rea kommenteerimiseks!
</source>

<source lang="php">
echo "Tere Priit"; // siin trükitakse välja tekst "Tere Priit"
</source>

===Muutujad ja väärtuse omistamine===

PHP skriptis on tähtsal kohal muutujad. Muutuja nime alguses on dollar ($), millele järgneb alakriips või tähemärk (a-z, A-Z) ning seejärel võib nimes sisalduda ka numbreid (0-9). PHP eristab väikesi ja suuri tähti. Muutujatel saavad olla mitmeid erinevaid väärtuseid, nagu näiteks:

<source lang="php">
$muutuja = "Tere maailm!"; // tekstiline väärtus
$muutuja = 24,7;           // komaga arv
$muutuja = 2010;           // täisarv
$muutuja = true;           // tõene või väär
$muutuja = NULL;           // NULL tähendab, et muutujal pole mingit väärtust

$muutuja = array( "mina", "sina", "tema" ); // massiiv
</source>

On ka veel objekt ja ressurss, millest siinkohal rohkem juttu ei teeks.

Erinevalt mõnedest programmeerimiskeeltest, ei pea PHP-s olema muutuja tüüpi eelnevalt defineeritud. Piisab muutujale väärtuse omistamisest, mida tehakse võrdusmärgi abil. 
Näiteks:

<source lang="php">
<?php
$a = -15.5; $b= 20;
$c = $a + $b;
?>

<?php
echo "$a korda $b on $c";
?>
</source>

Negatiivse arvu ees on - märk.

Pange tähele, et <?php ja ?> märkide vahel (plokis) kasutatud muutujad omavad endisi väärtusi ka järgnevates PHP plokkides.

<source lang="php">
$d = "muinas";
$e = "jutt";
$f = $d.$e;

echo "sõnesid $d ja $e saab kokku ühendada, tulemuseks on $f";
</source>

Sõnedega (ingl. k. string) tegelemisel on põhiliseks tehteks nende sobivas järjekorras kokkuühendamine. Allpool näitame, kuidas sõne osadeks lahutada jms.

Omistamisel saab kasutada

<source lang="php">
$a = 5;
$a = $a + 4;
</source>

asemel samaväärset kuid lühemat kirjaviisi

<source lang="php">
$a = 5;
$a += 4;
</source>

Muutujale saab omistada operatsioonisüsteemi käsu väljundit kasutades graaviseid. Käsk antakse kasutaja httpd õigustes. Näiteks omistame muutujale $aeg väärtuseks süsteemi aja

<source lang="php">
$aeg=`date`;
</source>

===Aritmeetilised tehted===

Aritmeetilisi tehteid

* "+, -" - liitmine ja lahtutamine
* "*, /, %" - korrutamine, jagamine ja jääk 

tehakse arvväärtustega. 
Näiteks leidmaks muutuja a ja be korrutist:

<source lang="php">
<?php
$a = 3.5;
$b = 2;
$korrutis = $a * $b;
echo "$a ja $b korrutis on $korrutis";
?>
</source>

Siiski, saaks ka lühemalt:

<source lang="php">
<?php
$a = 3.5;
$b = 2;
echo "$a ja $b korrutis on ".$a * $b;
?>
</source>

Kui arvutuses kasutada täisarvu ja komakohtadega arvu, siis tulemus sisaldab samuti komakohti.

===Juhtstruktuurid===

Skripti käigu suunamiseks kasutatakse juhtstruktuure, mis valivad järneva tegevuse vastavalt seatud tingimustele. Tingimusi esitatakse võrdlustehete <, >, <=, >=, ==, != ja <> abil. Võrdlustehete tulemusi (tõene, väär) saab omakorda kombineerida loogiliste tehete (and, or, xor, ! $a - not $a) abil.

Loogelisi sulge ({ ja }) kasutatakse käskude grupeerimiseks ühte plokki.

====if====

if konstruktsiooni abil saab valida kahe võimaliku tegevuse vahel sõltuvalt tingimuse täidetusest.

Võrdleme kahte arvu omavahel:

<source lang="php">
$a = 5; $b = 6;
if ($a > $b) 
{
  print "$a on suurem kui $b";
} 
else 
{
  print "$a on väiksem või võrdne $b-ga";
}
</source>

Kombineerides kahte tingimust loogilise tehtega võrdleme arve nulliga

<source lang="php">
$a = 5; 
$b = 6;

if ($a > 0 and $b > 0) 
{
  print "$a ja $b on nullist suuremad";
} 
elseif ($a < 0 and $b <  0) 
{
  print "$a ja $b on nullist väiksemad";
} 
else 
{
  print "$a ja $b on mõlemad nullid või erimärgilised";
}
</source>

====for====

for-konstruktsiooni abil saab täita sama plokki kontrollitud arv kordi. 
Näiteks kirjutab skript ekraanile arvud ühest viieni:

<source lang=php>
for ($i = 1; $i <= 5; $i++)
{
  echo "$i";
}
</source>

$i++ on samaväärne kui $i=$i+1. Muutuja $i väärtust suurendatakse ühe võrra!

Sama tulemuse väljastab ka järgmine skript:

<source lang=php>
$i = 1;
for (;;) 
{
  if ($i > 5) break;
  print $i;
  $i++;
}
</source>

for (;;) vastab lõpmatule kordusele. Samas break, annab käsu katkestada kordus.

====while====

while konstruktsiooni puhul täidetakse plokki seni, kuni tingimus on tõene. Trükime arvud ühest viieni välja ka while'i abil

<source lang=php>
$i = 1;
while ($i <= 5) 
{
  print $i++;  
}
</source>

Järgmine näide demonstreerib eel- (++$i) ja järel- ($i++) inkrementeerimist.

<source lang=php>
$i = 1;
while ($i <= 5) 
{
  print $i++;  
  print ++$i;
}
</source>

Tulemuseks on:

133557

* eel-inkrementeerimisel (++$i) suurendatakse muutuja väärtust enne ja allest siis kasutatakse seda, näiteks trükitakse
* järel-inkrementeerimisel ($i++) kasutatakse enne muutuja väärtust, näiteks trükitakse ja alles siis suurendatakse muutuja väärtust

====do ... while====

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. Näiteks trükime välja arvud ühest viieni

<source lang=php>
$i = 0;
do {
  print $i;
} while ($i>0);
</source>

====foreach====

foreach - konstruktsioon võimaldab mugavalt täita plokis olevaid lauseid iga massiivi elemendi jaoks. Näiteks väärtustame viie-elemendilise massiivi $m ning trükime selle elemendid välja

<source lang=php>
$m = array ("Jaan", "Peeter", "Marta", "Laura");
$i=1;
foreach ($m as $element) {
  print $i++.". $element";
}
</source>

===Trükkimine===

Teksti ja muutujate väärtuste ekraanile trükkimiseks kasutatakse käske echo, print ja printf. Käsud echo ja print on praktiliselt sarnased, väljatrükitav tekst tuleb kirjutada nende järele jutumärkide (") vahele. Järgmine skript trükib välja teksti, muutuja nimed ja nende väärtused

<source lang=php>
$a = "Mari";
$b = 5;
$c = -2;
$korrutis = $b * $c;
echo "$b korda $c on 
võrdne 
$korrutis";
print "
";
print "\$a = $a";
</source>

Nii echo kui print argumendiks olev tekst võib ulatuda üle mitme rea, tingimusel, et viimase rea lõpus on semikoolon (;). Soovides trükkida muutuja väärtuse asemel tema nime, tuleb põgeda $ tagurpidi kaldkriipsuga (\) nagu \$a.

Kui kasutada jutumärkide asemel ülakomasid, ei asendata muutujaid nende väärtustega:

<source lang=php>
$b = 5;
$c = -2;
$korrutis = $b * $c;
echo '$b korda $b on $korrutis';
</source>

Soovides vormistada (format) väljundit paindlikumalt, tuleb kasutada käsku printf, mille süntaks on sarnane C vastavale käsule. Näiteks teeme arvutused ja trükime välja muutujate väärtused kahe pealekomakohaga

<source lang=php>
$b = 1.3;
print "<pre>";
while ($b < 5)
{
  printf ("%3.2f%6.2f\n", $b, $b*$b++);
}
print "</pre>";
</source>
 
%6.2f tähendab, et trükkimisel tuleb korrutisele $b*$b++ vastav väli hoida vähemalt kuue positsiooni laiune, millest kaks on pealekomakohad. Vaikimisi täidetakse tühjad kohad tühikutega ja joondatakse paremale poole, so tühikud sisestatakse väärtusest vasemale. Siin on asjakohane kasutada HTMLi pre-tagi, sest muidu "sööb" brauser tühikud ära. Tulemus

      1.30     1.69
      2.30     5.29
      3.30    10.89
      4.30    18.49

===Funktsiooni defineerimine===

Kõiksugustes programmeerimis- ja skriptimiskeeltes üritatakse võimalikult vähe end koodi kirjutamisel korrata. Selleks on loodud funktsioonid.

Tekitame näiteks funktsiooni liida(), mis vajab sisendargumendiks kahte arvulist argumenti ning leiab nende kahe arvu summa.

<source lang=php>
function liida($a, $b) 
{
  $summa = $a + $b;
  echo "Arvude $a ja $b summa on $summa <br/>";
}

liida(10, 15);
liida(22, 11);
</source>

Tulemus:

     Arvude 10 ja 15 summa on 25
     Arvude 22 ja 11 summa on 33

Järgnev funktsioon korruta() vajab kahte sisendargumenti ($a ja $b), leiab nende korrutise ning tagastab põhiprogrammile tulemuse.

<source lang=php>
$a = 2;  
$b = 3;
 
function korruta ($a, $b) 
{
  $korrutis = $a * $b;
  $a = 10;
  $b = 15;
  return $korrutis;
}

$tulemus = korruta($a, $b);
print "$a * $b on võrdne $tulemus";
</source>

Tulemus:

    2 * 3 on võrdne 6

Eelnevas näites tagastatakse põhiprogrammile korrutise tulemus. Samas, kuigi funktsiooni sees omistatakse muutujatele $a ja $b uued väärtused, ei mõjuta see skripti põhiosas $a ja $b väärtusi. Funktsiooni sees olevad muutujad on põhiprogrammi osast eraldi.

Soovides aga funktsiooni seest muuta skripti muutujaid, tuleb anda funktsioonile üle muutuja viide. Selleks kirjutatake muutuja nime ette ampersand (&)

<source lang=php>
$a = 2;  
$b = 3;
 
function korruta ($a, $b) {
  $korrutis = $a * $b;
  $a = 10;
  $b = 15;
  return $korrutis;
}

$tulemus = korruta(&$a, &$b);
print "$a * $b on võrdne $tulemus";
</source>

Tulemus:

    2 * 3 on võrdne 6 

Sedamoodi muutujate väärtuste muutmine on ohtlik, sestnii on teinekord keerukas võimalikke vigu leida ning see võib teha skripti haavatavaks.

Operatsioonid sõnedega

PHP pakub vahendeid tegeleda sõnedega (ingl. k. string). Näiteks ühendame kokku kaks sõnet, omistades tulemuse muutujale $koos

<source lang=php>
$a = "Tere,";
$b = " mina siin";
$koos = $a.$b;
</source>

Käsuga strlen saab leida sõne pikkuse tähemärkides

<source lang=php>
$sone = "Taavet ja Koljat";
$pikkus = strlen ($sone);
</source>

Käsk strstr tagastab sõne, mille väärtuseks on tähemärgid alates leitud sõnest kuni lõpuni, näiteks:

<source lang=php>
$email = 'priit@zoo.edu.ee';
$domain = strstr ($email, '@');              
print $domain;   
</source>

Tulemus:

     @zoo.edu.ee.

Sõnest eraldab osa käsk substr, näiteks eemaldame kõik peale esimese tähemärgi:

<source lang=php>
$domain = "@zoo.edu.ee";
$domaininimi = substr ($domain, 1);
</source>

$domaininimi väärtuseks saab zoo.edu.ee.

Veebivormidega tegeledes kasutatakse tihti sarnase struktuuriga sõnesid "nimi=Villem&vanus=25&elukoht=Tartu+linn". Käsu parse_str abil on lihtne omistada muutujaile vastavad väärtused. 
Näiteks:

<source lang=php>
$str = "nimi=Villem&vanus=25&elukoht=Tartu+linn";
parse_str($str);                          
echo "$nimi";
echo "$vanus";
echo "$elukoht";
</source>

===Massiivid===

Massiiv (ehk jada) on justkui muutuja, mis hoiab endas ühe väärtuse asemel mitut väärtust. Igal massiivil on elemendid, igal elemendil on koht massiivis.

Defineerime massiivi $mass koos mõne elemendiga ja kuvame need ekraanile

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$a = current($mass);
do {
  echo "$a <br/>";
} while ($a = next($mass));
</source>

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

Samalaadne kuvamine foreach käsku kasutades.

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
foreach( $mass as $value )
  echo "$a <br/>";
</source>


Omades sõnet

<source lang=php>
$sone = "Priit Jaan Memm       Kana  Ivo";
</source>

saab selle teisendada tühikute kohalt massiiviks käsuga split

<source lang=php>
$mass = split (" +", $sone);
</source>

kus " +" on regulaaravaldis. Kui tulevase massiivi elemente eraldaks üks tühik, võiks kasutada sarnaselt käsku explode.

<source lang=php>
$sone = "Priit Jaan Memm Kana Ivo";
$mass = explode (" ", $sone);
</source>

Vastupidiselt, massiivi saab ühendada sõneks käsuga join

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$sone = join (":", $sone);
</source>

Tulemuseks on sõne:

     Priit:Jaan:Memm:Kana:Ivo

Massiivi elementide poole saab pöörduda indeksi abil. Vaikimisi algab indekseerimine nullist. 
Näikeks trükime üle ühe välja massiivi elementide väärtused:

<source lang=php>
for ($i=0; $i < sizeof ($mass); $i+=2)
{
  print "$i. ".$mass[$i];
}
</source>

Funktsioon sizeof tagastab massiivi elementide arvu ning konstruktsioon $i+=2 suurendab iga kordusega muutuja $i väärtust kahe võrra. Konstruktsioon $mass[$i] abil pöördutakse massiivi $mass $i-nda elemendi poole.

Käsk array_pop tagastab massiivi viimase elemendi väärtuse ja eemaldab ta massiivist

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$viimane = array_pop ($mass);
</source>

Käsk array_shift tagastab massiivi esimese elemendi väärtuse ning eemaldab ta massiivist; ülejäänud elemendid nihutatakse ühe positsiooni võrra ettepoole

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$viimane = array_shift ($mass);
</source>

Sarnaselt lisatakse masiivi algusse ja lõppu elemente käskudega array_unshift array_push

<source lang=php>
$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$elementide_uus_arv = array_unshift ($mass, "Laine", "Jaa");
$elementide_uus_arv = array_push ($mass, "Leo", "Liina");
</source>

Tulemuseks on massiiv ("Laine", "Jaa", "Priit", "Jaan", "Memm", "Kana", "Ivo", "Leo", "Liina"), kusjuures mõlemad käsud tagastavad väärtusena uue massiivi elementide arvu.

===Assotsiatiivne massiiv===

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

<source lang=php>
$massiiv[0] = "Jaan";
$massiiv[1] = "Peeter";
$massiiv[2] = "Laur";
</source>

või siis

<source lang=php>
$massiiv = array( "Jaan", "Peeter", "Laur" );
</source>

Teise elemendi poole pöördumiseks:

<source lang=php>
print "$massiiv[1]";
</source>

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

<source lang=php>
$inimesed["Priit"] = "21";
$inimesed["Jaan"] = "54";
</source>

ning pöördume teise elemendi poole

<source lang=php>
print $inimesed["Jaan"];
</source>

Tulemusena tagastatakse väärtus 54.

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

<source lang=php>
$inimesed = array ("Priit" => "21", "Jaan" => "54", "Memm" => "67", "Kana" => "82", "Ivo" => "14"); 
while (list ($nimi, $vanus) = each ($inimesed))
{
  echo "$nimi $vanus <br/>";
}
</source>

Esmalt 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.

<source lang=php>
$inimesed = array ("Priit" => "21", "Jaan" => "54", "Memm" => "67", "Kana" => "82", "Ivo" => "14"); 
foreach( $inimesed as $nimi => $vanus )
  echo "$nimi $vanus <br/>";
</source>

Siin täpselt sama massiiv kuid kõikide elementide kätte saamiseks kasutatakse foreach funktsiooni.

Teisendame tavalise massiivi assotsiatiivseks

<source lang=php>
$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";
}
</source>

Käsuga array_keys saab assotsiatiivsest massiivist kätte kõik võtmed, mis tagastatakse tavalise massiivina,

<source lang=php>
$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>";
}
</source>

===Emaili saatmine===

Emaili saab välja saata kahel viisil

* nö php rakendusega samas arvutis oleva /usr/sbin/sendmail abil, see eeldab, et arvuti oskab toimetada posti välja (nt arvutis töötab kohalik Postfix deemon)
* php rakendus pöördub ise otse võrgus töötava smtp relee poole

====/usr/sbin/sendmail abil====

Maili saatmine käib mail funktsiooni kasutades. Lihtne skript:

<source lang=php>
<?php
$to = "kasutaja@test.ee";
$subject = "TEST SUBJECT";
$message = "Hello! \n";
$message .= "More blah blah blah \n";
$message .= "blah blah blah blah blah blah blah blah blah \n";
$headers = "From: kasutaja@test.ee \r\n" .
"Reply-To: kasutaja@test.ee \r\n" .
"X-Mailer: PHP/" . phpversion();
mail($to, $subject, $message, $headers);
echo $headers;
?>
</source>

====SMTP relee kaudu====

PHP Pear mooduli Net_SMTP http://pear.php.net/package/Net_SMTP/ abil saab saata SMTP relee kaudu kirju välja, tarkvara paigaldamiseks tuleb nt Debian operatsioonisüsteemis öelda

 # apt-get intall php-mail

Näiteks selline skript saadab kirja välja

<source lang=php>
 <?
 
 require 'Net/SMTP.php';
 
 $host = '192.168.1.250';
 $from = 'mart@loomaaed.tartu.ee';
 $rcpt = array('priit@loomaaed.tartu.ee');
 $subj = "Subject: Teade, mis on tähtis\n";
 $body = "Kirja sisu osa";
 
 /* Create a new Net_SMTP object. */
 if (! ($smtp = new Net_SMTP($host))) {
    die("Unable to instantiate Net_SMTP object\n");
 }
 
 /* Connect to the SMTP server. */
 if (PEAR::isError($e = $smtp->connect())) {
   die($e->getMessage() . "\n");
 }
 
 /* Send the 'MAIL FROM:' SMTP command. */
 if (PEAR::isError($smtp->mailFrom($from))) {
   die("Unable to set sender to <$from>\n");
 }
  
 /* Address the message to each of the recipients. */
 foreach ($rcpt as $to) {
   if (PEAR::isError($res = $smtp->rcptTo($to))) {
     die("Unable to add recipient <$to>: " . $res->getMessage() . "\n");
    }
 }
 
 /* Set the body of the message. */
 if (PEAR::isError($smtp->data("From: Mart Kask <mart@loomaaed.tartu.ee>\r\n" . "To: Priit Kask <priit@loomaaed.tartu.ee>\r\n" . $subj . "\r\n" . $body))) {
   die("Unable to send data\n");
 }
 
 /* Disconnect from the SMTP server. */
 $smtp->disconnect();
 
 ?>
</source>

===MySQL-andmebaasiga suhtlemine===

PHP pakub vahendid MySQL-andmebaasiga suhtlemiseks. Järgnevas näitame, kuidas kasutada MySQL palas tarvitatud andmebaasi puhul. Andmebaasiga suhtlemiseks peab PHP skript kõigepealt näitama andmebaasiserveri nime, kasutajanime, parooli ning kasutatava andmebaasi nime. Praktiliselt tähendab see, et need väärtused tuleb sisestada PHP skripti avatekstina, mis pole aga tingimata ebaturvaline, kuna PHP skripti ennast veebikoha külastaja ei näe.
    
====Andmebaasi kirjete kuvamine====

Skript kuvab andmebaasis oleva tabeli inimesed kõik kirjed (read)

<source lang=php>
// Ühendume andmebaasiserveriga
$ab = mysql_connect("www.zoo.edu.ee", "zoo", "zooparool");

// valime andmetabeli
mysql_select_db("zoo", $ab);

// esitame päringu
$tulemus = mysql_query("SELECT * FROM inimesed", $ab);

print "<pre>";

// kuni päringutulemuste lõppemiseni, täidame nendega assotsiatiivse massiivi $rida ning trükime selle elementide väärtused
while ($rida = mysql_fetch_assoc($tulemus)) 
{
  printf ("%12s %15d %15s\n",$rida["nimi"], $rida["vanus"], $rida["elukoht"]);
}
print "</pre>";
</source>

====Andmebaasi kirjete lisamine====

Skript lisab andmebaasi kirje

<source lang=php>
<?php
if (isset( $_GET['submit_to_sql'] ))
{
  // Ühendume andmebaasiserveriga
  $ab = mysql_connect("www.zoo.edu.ee", "zoo", "zooparool");

  // valime andmetabeli
  mysql_select_db("zoo", $ab);

  $vanus = (int) $_GET['vanus'];
  $nimi = mysql_real_escape_string( $_GET['nimi'] );
  $elukoht = mysql_real_escape_string( $_GET['elukoht'] );

  // kirjeldame päringu
  $sql = "INSERT INTO rahvas VALUES ( '".$nimi"', '".$vanus."', '".$elukoht."' )";

  // teostame päringu
  $tulemus = mysql_query ($sql);
  echo "<p>Asi valmis!<p>";
}
?>

<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>" >
Nimi: <input type="text" name="nimi" /><br/>
Vanus: <input type="text" name="vanus" /><br/>
Elukoht:< input type= "text" name="elukoht" /><br/>
<input type="submit" name="submit_to_sql" value="Sisestan andmed" />
</form>
</source>

Antud näite põhjal postitab skript vormi sisu ise endale. Esmakordsel laadimisel pole veel midagi postitatud ja seetõttu on muutuja $_GET['submit_to_sql'] väärtustamata. 

Tingimuse if (isset( $_GET['submit_to_sql'] )) plokk jäetakse täitmata ja esitatakse ainult vorm. Vormi ACTIONiks oleva muutuja $PHP_SELF väärtus on alati võrdne skripti URLiga, näiteks http://www.zoo.edu.ee/skript.php. Täites vormi ja vajutades "Sisestan andmed" nupule, postitatakse vormi sisu. 

Andmebaasi ühendus lõpetatakse automaatselt peale skripti täitmise lõppu.

Oluline on täheldada, et osad andmed on läbinud funktsiooni mysql_real_escape_string. See funktsioon hoolitseb selle eest, et sisestatud teksti sees saaksid eemaldatud kõik sellised märgid, mis võivad rikkuda teie SQL päringu ja võimaldada häkkeritel moodustada selliseid päringuid, mis lubavad neil manipuleerida teie andmebaasiga.

===PostgreSQLi andmebaasiga suhtlemine===

PHP pakub vahendid PostgreSQLi andmebaasiga suhtlemiseks. Järgnevas näitame, kuidas kasutada PostgreSQLi palas tarvitatud andmebaasiga. Andmebaasiga suhtlemiseks peab PHP skript kõigepealt näitama andmebaasiserveri nime, kasutajanime, parooli ning kasutatava andmebaasi nime. Praktiliselt tähendab see, et need väärtused tuleb sisestada PHP skripti avatekstina, mis pole aga tingimata ebaturvaline, kuna PHP skripti ennast veebikoha külastaja ei näe.

====Andmebaasi kirjete kuvamine====

Skript kuvab andmebaasi tabeli inimesed kõik kirjed

<source lang=php>
// Ühendume andmebaasiserveriga
$ab = pg_connect ("host=www.zoo.edu.ee user=zoo dbname=zoo password=zooparool")

// esitame päringu
$tulemus = pg_exec ($ab, "SELECT * FROM inimesed");

// saame teada, mitu rida päringule vastasid
$ridu = pg_numrows($tulemus); 

print "<pre>";

// kuni päringutulemuste lõppemiseni täidame nendega
// assotsiatiivse massiivi $rida ning trükime selle elementide väärtused
for ($i = 0; $i < $ridu; $i++) 
{
  $rida = pg_fetch_array($tulemus, $i);
  printf ("%12s %15d %15s\n", $rida["nimi"], $rida["vanus"], $rida["elukoht"]);
}
print "< /pre >";
</source>

====Andmebaasi kirjete lisamine====

Skript lisab andmebaasi kirje

<source lang=php>
<?php
if (isset( $_GET['submit_to_sql'] ))
{
  // Ühendume andmebaasiserveriga
  $ab = pg_connect ("host=www.zoo.edu.ee user=zoo dbname=zoo password=zooparool");

  // kirjeldame päringu
  $sql = "INSERT INTO inimesed VALUES ('$nimi','$vanus','$elukoht')";

  // teostame päringu
  $tulemus = pg_exec ($ab, $sql);
}
?>
<form method="post" action="<?php echo $_SERVER['PHP_SELF'] ?>" >
Nimi: <input type="text" name="nimi" /><br/>
Vanus: <input type="text" name="vanus" /><br/>
Elukoht:< input type= "text" name="elukoht" /><br/>
<input type="submit" name="submit_to_sql" value="Sisestan andmed" />
</form>
</source>

===Sessioonid===

Sessioone kasutatakse teatud info talletamiseks ajal, kuni kasutaja on lehel. Sessioonid luuakse pea alati, kui on võimalik mingisse portaali sisse logida. Sessioonide kestvus sõltub paljugi serveri konfiguratsioonist. Üldiselt on see aeg vägagi piiratud!

Sessiooni käivitamiseks on funktsioon session_start();

Sessioonil on PHP's globaalne muutuja $_SESSION, milles hoitakse sessiooni sisestatud infot.

Et luua lihtsat sisselogimist, peame sessiooni lisama indeksi ja väärtuse, mille kontrollimisel selgub kasutaja roll lehel. Olgu selleks indeksiks "logitud".

PHP's saame teha kontrolli, kas kasutaja on sisse logitud... Kui on, siis kuvame talle lehe sisu. Vastasel juhul keelame lehe sisu kuvamise.

<source lang=php>
<?php
session_start();

if (isset( $_SESSION['logitud'] ) and $_SESSION['logitud'] == true )
{
  // kuvame sisselogitule vajaliku info
}
else
{
  echo "Palun logi sisse!";
}
?>
</source>

If kontrollib, kas selline indeks nagu "logitud" on sessioonis olemas ning kui on, siis kontrollib kas selle väärtus on tõene. Kui mõlemad tingimused on tõesed, kuvatakse kasutajale vastav sisu.

Sedasi. Kuidas siis sisse logida? Selleks tuleks teha vastav vorm, kus oleks ka kontroll ja sessiooni muutuja määramine.

<source lang=php>
<?php

if (isset( $_GET['user_login'] ))
{
  // kontrollime andmebaasi põhiselt, kas kasutajatunnus ja parool klapivad...
  // või siis määrame ise tekstilise kasutaja ja parooli nagu
  // $usr = "kasutaja";
  // $pwd   = "parool";
  // ning kontrollime nende kattuvust sisestatud infoga:
  // if ( $usr == $_GET['user'] and $pwd == $_GET['pass'] ) $_SESSION['logitud'] == true;
  // siinkohal oleks ka viisakas kasutaja suunata uuele lehele ...
}

<form method="post" action="<?php echo $_SERVER['PHP_SELF']; ?>
Kasutaja: <input type="text" name="user" value="" /><br/>
Parool: <input type="test" name="pass" value="" /><br/>
<input type="submit" name="user_login" value="Logi sisse" />
</form>
</source>

Peale seda, kui vormist on info postitatud ja skript leiab andmed korrektsed olevat, muudetakse sessioonis oleva indeksi "logitud" väärtus tõeseks. Peale seda on mõlemad tingimused tõesed:

<source lang=php>
if (isset( $_SESSION['logitud'] ) and $_SESSION['logitud'] == true )
{

}
</source>

Pange tähele, et PHP's kontrollitakse muutujate vastavust topelt võrdusega (==). Ühekordne võrdus (=) on vaid väärtuse omistamiseks muutujale!

===URL ja muutujad===

Kui skriptile postitatakse andmeid, on võimalik neid peita (POST meetod) või kuvada aadressireal (GET meetod). Vastav meetod tuleb kirjutada <form> käsu sisse.

Näiteks form1.php:

<source lang=php>
<form method="post" action="form1.php">
<input type="text" name="nimi" value="Jaan Tamm" />
<input type="submit" name="postita" value="Postita" />
</form>
</source>

Peale vormi postitamist on aadressireal vaid failinimi.

     http://<veebiserver>/vorm.php 

GET meetod... Näiteks form2.php:

<source lang=php>
<form method="get" action="form2.php">
<input type="text" name="nimi" value="Jaan Tamm" />
<input type="submit" name="postita" value="Postita" />
</form>
</source>

Peale vormi postitamist on aadressireal peale failinime ka lisainfot:

     http://<veebiserver>/vorm.php?nimi=Jaan+Tamm&postita=Postita

PHP5'st alates hoitakse aadressireal olevat infot erilises muutujas, milleks on $_GET. Tegu on massiiviga. 

Kui soovime postitatud muutujad "nimi" ekraanile tuua, lisame form2.php sisse järgneva koodi:

<source lang=php>
<?php

echo $_GET['nimi'];

?>
</source>

Tulemuseks väljastatakse massiivis $_GET pesa "nimi" väärtus, milleks on

     Jaan Tamm

Juhul, kui aadressireal on vaid "vorm2.php", siis kuvatakse PHP's veateade. Seda põhjusel, et $_GET muutujas pole "nimi" nimelist pesa. Veateate välistamiseks teeme ühe eelneva kontrolli:

<source lang=php>
<?php

if ( isset( $_GET['nimi'] ) )
  echo $_GET['nimi'];

?>
</source>

Nüüd tehakse enne väärtuse väljastamist kontroll, kas selline pesa nagu "nimi" on jadas defineeritud. Kui ei, siis ei väljastata midagi.

Alati pole vorm otstarbekas. Saab ka näiteks nii:

<source lang=php>
<a href="vorm2.php?nimi=Mart">Mart</a>
</source>

https://wiki.itcollege.ee/index.php/PHP_seadistamine

===Faili üleslaadimine===

Faili üleslaadimiseks tuleb esitata veebiserveri kaks päringut

* ülelaadimise vormi esitamise GET päring
* faili üleslaadimise POST päring

Üleslaadimise vorm võiks olla nt selline

 <form enctype="multipart/form-data" action="uploader.php" method="POST">
   <input type="hidden" name="MAX_FILE_SIZE" value="100000" />
   Näita üleslaaditav faili: <input name="uploadedfile" type="file" /><br />
   <input type="submit" value="Upload File" />
 </form>

kus

* MAX_FILE_SIZE - piirab üleslaadimise suurust

POST päringut töötlev skript võiks olla nt selline

 <?
   $target_path = "uploads/";
   $target_path = $target_path . basename( $_FILES['uploadedfile']['name']); 
   
   if(move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target_path)) {
     echo "Fail ".  basename( $_FILES['uploadedfile']['name']). "laaditi üles";
   } else{
     echo "Faili üleslaadimisel esines viga!";
   }
  
 ?>

Üleslaadimise kasutamiseks peab lisaks olema skriptiga samas kataloogis kataloog uploads, mis on veebiserveri kasutajale kirjutatav. Üleslaadimist kontrollitakse lisaks vormi juures näidatud MAX_FILE_SIZE parameetrile erinevate süsteemse php.ini seadistusfaili parameetritega, nt

* post_max_size = 1M
* file_uploads = On
* upload_max_filesize = 1M

Lisaks saab üleslaadimist kitsendada Apache seadistusfailist direktiiviga

 LimitRequestBody 102400

===PHP skript pöördub välja===

Eeldusel, et php.ini failis on lubatud, saab php skript pöörduda üle võrgu arvutist välja, nt

 allow_url_fopen = On

 <?
  $fp = fsockopen("ftp.aso.ee", 80, $errno, $errstr, 30);
  if (!$fp) {
    echo "$errstr ($errno)\n";
  } else {
    $out = "GET /README HTTP/1.1\r\n";
    $out .= "Host: ftp.aso.ee\r\n";
    $out .= "Connection: Close\r\n\r\n";
 
    fwrite($fp, $out);
    while (!feof($fp)) {
      echo fgets($fp, 128);
    }
    fclose($fp);
 }
 ?>

===Lingid===

http://php.net/supported-versions.php Serveriarendajad saavad siit vaadata hetkel ametlikult toetatud versioonide numbreid, ning samuti kontrollida ega nende kasutatav versioon peagi ei aegu.