Php

Allikas: Kuutõrvaja

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 

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

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

<html>
<body>
<h1>Tere päevast!</h1>
<p>Mina olen PHP skritp.</p>
</body>
</html>

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 

echo "Tere päevast!";

PHP skripti sisse saab kirjutada kommentaare. Näiteks: 

/* see on kommentaar,
mida PHP mootor ignoreerib... */

või 

// ühe rea kommenteerimiseks!

echo "Tere Priit"; // siin trükitakse välja tekst "Tere Priit"

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: 

$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

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: 

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

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

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. 

$d = "muinas";
$e = "jutt";
$f = $d.$e;

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

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 

$a = 5;
$a = $a + 4;

asemel samaväärset kuid lühemat kirjaviisi 

$a = 5;
$a += 4;

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 

$aeg=`date`;

Aritmeetilised tehted

Aritmeetilisi tehteid

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

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

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

Siiski, saaks ka lühemalt: 

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

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: 

$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";
}

Kombineerides kahte tingimust loogilise tehtega võrdleme arve nulliga 

$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";
}

for

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

for ($i = 1; $i <= 5; $i++)
{
  echo "$i";
}

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

Sama tulemuse väljastab ka järgmine skript: 

$i = 1;
for (;;) 
{
  if ($i > 5) break;
  print $i;
  $i++;
}

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 

$i = 1;
while ($i <= 5) 
{
  print $i++;  
}

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

$i = 1;
while ($i <= 5) 
{
  print $i++;  
  print ++$i;
}

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 

$i = 0;
do {
  print $i;
} while ($i>0);

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 

$m = array ("Jaan", "Peeter", "Marta", "Laura");
$i=1;
foreach ($m as $element) {
  print $i++.". $element";
}

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 

$a = "Mari";
$b = 5;
$c = -2;
$korrutis = $b * $c;
echo "$b korda $c on 
võrdne 
$korrutis";
print "
";
print "\$a = $a";

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: 

$b = 5;
$c = -2;
$korrutis = $b * $c;
echo '$b korda $b on $korrutis';

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 

$b = 1.3;
print "<pre>";
while ($b < 5)
{
  printf ("%3.2f%6.2f\n", $b, $b*$b++);
}
print "</pre>";

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

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

liida(10, 15);
liida(22, 11);

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. 

$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";

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 (&) 

$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";

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 

$a = "Tere,";
$b = " mina siin";
$koos = $a.$b;

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

$sone = "Taavet ja Koljat";
$pikkus = strlen ($sone);

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

$email = 'priit@zoo.edu.ee';
$domain = strstr ($email, '@');              
print $domain;

Tulemus: 

    @zoo.edu.ee.

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

$domain = "@zoo.edu.ee";
$domaininimi = substr ($domain, 1);

$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: 

$str = "nimi=Villem&vanus=25&elukoht=Tartu+linn";
parse_str($str);                          
echo "$nimi";
echo "$vanus";
echo "$elukoht";

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 

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

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

Samalaadne kuvamine foreach käsku kasutades. 

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


Omades sõnet 

$sone = "Priit Jaan Memm       Kana  Ivo";

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

$mass = split (" +", $sone);

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

$sone = "Priit Jaan Memm Kana Ivo";
$mass = explode (" ", $sone);

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

$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$sone = join (":", $sone);

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: 

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

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 

$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$viimane = array_pop ($mass);

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

$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$viimane = array_shift ($mass);

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

$mass = array ("Priit", "Jaan", "Memm", "Kana", "Ivo");
$elementide_uus_arv = array_unshift ($mass, "Laine", "Jaa");
$elementide_uus_arv = array_push ($mass, "Leo", "Liina");

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 

$massiiv[0] = "Jaan";
$massiiv[1] = "Peeter";
$massiiv[2] = "Laur";

või siis 

$massiiv = array( "Jaan", "Peeter", "Laur" );

Teise elemendi poole pöördumiseks: 

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))
{
  echo "$nimi $vanus <br/>";
}

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. 

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

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

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, mis tagastatakse tavalise massiivina, 

$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>";
}

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: 

<?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;
?>

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 

 <?
 
 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();
 
 ?>

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) 

// Ü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>";

Andmebaasi kirjete lisamine

Skript lisab andmebaasi kirje 

<?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>

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 

// Ü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 >";

Andmebaasi kirjete lisamine

Skript lisab andmebaasi kirje 

<?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>

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. 

<?php
session_start();

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

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. 

<?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>

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: 

if (isset( $_SESSION['logitud'] ) and $_SESSION['logitud'] == true )
{

}

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: 

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

Peale vormi postitamist on aadressireal vaid failinimi. 

    http://<veebiserver>/vorm.php

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

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

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: 

<?php

echo $_GET['nimi'];

?>

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: 

<?php

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

?>

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: 

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

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" />

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

Pärit leheküljelt "https://kuutorvaja.eenet.ee/w/index.php?title=Php&oldid=29078"