PHP Lietuviškai
Informacija iš interneto pakampiu surinko, visa savaitgali prie Easy PDF sedejo
ir kankinosi Justinas L. aka
scooox. Taigi, kad visi girdetu, sakau: šitas dokumentas yra surinktas iš visu
kampu ir aš nesisavinu sau jo
autorystes ar kaip ten sakoma =). Visa info apie autorius galite rasti apacioje...
Taigi šiek tiek api šita ebook'a. Kažkada seniai kažkur internete radau toki
archyva, pavadinimu php_lt.zip.
Pažiurejau - visai nieko, newbiams gerai. Taigi šitas php_lt.zip yra šio
dokumento (knygos, knygeles,
biblijos.. koks skirtumas) pagrindas. Taigi visa zip'a sugrudes i pdf'a
nusprendžiau ji papildyti ir informacija iš
geriausio lietuviško PHP resurso - beta.php.lt. Tai taip ir gavos šis failiukas,
kaip sakant viskas viename...
Taigi imkit mane ir skaitykit.. ir neuždavinekit tada kvailu klausimu #php
kanale :].
Turinys
1. Kas yra PHP?
1.1 Trumpa PHP istorija
1.2 PHP privalumai ir trukumai
2. Skriptai
3. Kintamieji ir kintamuju tipai
4. Veiksmai su kintamaisiais
5. Duomenu (kintamuju) perdavimas iš formos skriptui
5.1 Placiau apie funkcija mail()
5.1.1 php.ini konfiguravimas
5.1.2 Pradmenys
5.1.3 Antraštes (headeriai)
5.1.4 Apibendrinimas
6. Duomenu (kintamuju) gautu iš formos patikrinimas
7. Darbas su data ir laiku
8. Veiksmai su failais
8.1 Informacijos perskaitymas iš tekstinio failo
8.2 Naujas irašymas ištrinant visus senus duomenis
8.3 Irašymas neištrinant senu duomenu, o tesiant saraša toliau
8.4 Tekstine duomenu baze
8.5 Pilnos duomenu bazes struktura
9. REMOTE_HOST ir REMOTE_ADDR
10. Cookies
11. Ciklai
12. Salygos operatoriai
13. Sesijos
14. Objektinis programavimas
15. Tips and Tricks
15.1 parent ::
15.2 Pranešimai apie klaidas
15.3 Search Engine Friendly PHP pages
1. Kas yra PHP?
PHP (PHP hypertext preprocessor) tai skriptinimo kalba (scripting language) kuri
pacioje pradžioje buvo
orentuota tik i iterneta, nors šiuo metu ja galima "drasiai" pavadinti
programavimo kalba, kadangi su ja
pilnai galima programuoti ne tik internetui (web'ui). Pavyzdžiui su php-gtk
galima kurti pilnavertiškas cross
platformines programas su GUI (graphical user interface), bei consolines
programeles mail wrapperius ir t.t.
PHP skriptai yra interpretuojami ir ivykdomi serverio puseje. Pvz.:
<html>
<head>
<title>Pavyzdys</title>
</head>
<body>
<?php echo "Sveikas aš esu PHP skriptas"; ?>
</body>
Po šio skripto ivykdimo rezultate (naršykleje) turesime:
Sveikas aš esu PHP skriptas
Tai gana paprasta bet naudos iš to == nulis Pradžioje pagrindinis PHP privalumas
prieš CGI buvo tai kad
PHP skriptas galejo buti lengvai iterpiamas i HTML koda, kaip CGI reikejo visa
HTML outputint iš CGI skripto.
Kuo toliau tuo reciau HTML'as yra maišomas su HTML'u didesniuose projektuose,
tam naudojami
"Templait'ai" (šablonai?). Yra ir lietuviška templaitu klase - phemplate. Apie
ja daugiau informacijos rasite
cia.
PHP skirtumas nuo JavaScript yra tai jog PHP skriptai yra atliekami serverio
puseje o vartotojui yra
gražinamas rezultatas (HTML'u ar XML'u). Rezultata vartotojas mato savo
naršykleje. Tuo tarpu kai Java
Script yra pilnai perduodamas kliento mašinai (kompiuteriui) ir atliekamas
klientineje dalyje.
PHP sintakses pagrindai yra paiimti iš: C, Perl, Java, todel programavusiems
šiomis kalbomis yra ypatingai
lengva pradeti programuoti PHP.
1.1 Trumpa PHP istorija
Viskas prasidejo 1994 metu rudeni, kai Rasmus Lerdorf'as nusprende patobulinti
savo Home-Page (asmenini
puslapi) ir parašyti asmenini varikliuka kuris atlikinetu paprasciausius
veiksmus. Ši varikliuka parenge 1995
metu pradžioje ir pavadino "Personal Home Page Tools". Šie "tools'ai" mokejo ne
itin daug, ir galimybes jo
buvo tik pacios paprasciausios, sudare ja vos keleta makrosu. (Pati pirmaji
Rasmus Lerdorf'o pranešima i
www konferencija apie savo "Personal Home Page Tools" 1995 metais. Galite
paskaityti štai cia).
1995 metu viduryje atsirado antroji varikliuko versija kuri vadinosi PHP/FI
version 2. FI - del vienos
priežasties: tiesiog Rasmus'as padare papildoma paketa kuris jau mokejo
interpretuoti formas (Form
Interpretator). PHP/FI kompiliavosi i Apache Web serveri ir naudojo standartini
Apache API. PHP skriptai
pasirode spartesni serveryje nei CGI, nes nereikejo kurti naujo process'o. Po
truputi PHP pradejo lygintis
savo galimybemis su Perl'u (populiariausia kalba CGI rašymui). Su laiku buvo
prideta ir daugeliu duomenu
baziu palaikymas (MySQL, Oracle ir t.t.), interfeisas GD bibliotekai (parašytas
Rasmus'o ir iki šiol kuruojamas
jo) leido dinamiškai kurti paveiksliukus. PHP/FI labai greitai pradejo plisti.
1997 metu pabaigoje Zeev Suraski ir Andi Gutmans nusprende perrašyti PHP
varikliuka su tikslu ištaisyti
daugeli klaidu bei pagreitinti PHP skriptu atlikima serveryje. Po puses metu,
1998..06 išejo nauja versija kuri
buvo pavadinta PHP3. NetCraft'o duomenimis PHP 1999 metais naudojosi jau 1 mljn.
domenu.
1999 metu pabaigoje buvo velgi perrašytas PHP3 varikliukas (pavadinimu Zend
Engine) ir išleista nauja
versija PHP4. Skirtumai tarp šiu versiju yra tikrai dideli, kartu su pagrindiniu
PHP branduoliu atsirado
daugybe extension'u ir jie vis dar nenusutojami tobulinti ir rašyti (Extension'u
pvz: gd, xslt, sockets,imap,
daugeliu DB support'ai ir t.t. ir t.t.).
Šiuo metu (2002 metu sausis) yra ruošiamas velgi patobulintas PHP varikliukas
pavadinimu Zend Engine 2.
Jis bus išleistas 2002 metu viduryje. Zend Engine 2 ir bus PHP5 "širdis bei
smegenys". Pasak Zeev'o
daugiausia darbo bus ideta i naujo objektinio modulio tobulinima. Ištaisys
Objekto kopijavimo atmintyje
problema (dabar sunku atkasti ar tu sukuri jau esamo objekto kopija), ideologija
Zeev'as paeme iš Java.
Tiesiog kuriant objekta ( new Object() ) kintamasis nebus pats objektas o
tiesiog referenc'as i ji, taip
darant priskirima naujam kintamajam bus priskiriamas nebe pats objektas o jo
referencas (objektas
nekopijuojamas atmintyje). Taip pat atsiras destruktoriai, exception handler'iai
(try/throw/catch) ir
dauguma kitu pakeitimu (->_clone(),->_construct(), ->_destruct()...)
1.2 PHP privalumai ir trukumai
Apie privalumus ir trukumus prieš kitas panašaus tipo programavimo kalbas galite
rasti internete.
PHPEverywere turi puiku straipsniu rinkini apie PHP bei cfm,perl,jsp,asp. Aš
tiesiog paminesiu pagrindinius
privalumus ir trukumus nelygindamas su kitomis kalbomis.
Privalumai:
a) php yra visiškai nemokamas;
b) php yra visiškai cross platforminis ( veikia ivairiose operacinese sistemose:
Win, *nix, MacOS, Solaris,
HP-UX, AIX ir t.t.);
c) php yra opensourc'inis projektas todel ji developina didele grupe žmoniu,
todel iškile bug'ai yra greitai
ištaisomi, ir php sparciai pleciasi;
d) kaip ir cross platforminis jis veiki ir ant daugelio WEB serveriu: Apache,
IIS, PWS, OmniHTTP, BadBlue ir
t.t.;
e) išmokti PHP programavimo pagrindu yra labai lengva;
f) pasižymi dideliu greiciu serverio puseje, bei dirbant su duomenu bazemis;
g) nedideliuose projektuose PHP jus paprastai galite iterpti i savo HTML'a;
h) developer'iai priraše extension'u kiekvienam gyvenimo atvejui;
i) kadangi php programuotoju yra be galo daug, dauguma jau parašytu skriptu
galite rasti internete:
HotScripts, FreeScripts, PHPClasses.upperdesign.com ir t.t. ir t.t.
Trukumai:
a) PHP == interpretatorius (nors tiesa sakant man tai netrukdo);
b) kadangi PHP yra opensourc'inis projektas, jusu parašyti sourc'ai yra laisvai
prieinami (skaitomi). Taip
žinau yra ZendEncoder bet jis yra mokamas. Gerai kad nors jis yra;
c) deja php-gtk sourc'ai vis dar negali buti encodinam.1. Ivadas
2. Skriptai
Mes pabandysim paaiškinti "liaudiškai". Kas yra PHP, ir ka su šia programavimo
kalba imanoma padaryti? O
gi galima padaryti beveik viska, ko jums gali prireikti internete:
apsilankiusiuju skaitliukai, sveciu knygos,
forumai, skelbimu lentos ir daug daug kitu programu. PHP skriptai turi išpletima
.php Juos galima sutikti ir su
kitokiais išpletimais: .php .phtml .php3 .php4
Skripto kunas gali buti iterptas i bet kuria html vieta. Kunas (pats skripto
turinys) yra tarp štai tokiu
simboliu:
<?php
// štai cia rašomas pats skriptas
?>
arba
<?php /*Cia rašomas scripto tekstas*/ ?>
arba
<? /*Cia rašomas scripto tekstas*/ ?>
arba
<script language="php">
// cia iterpiamas scriptas
</script>
arba
<%
// iterpiamas tekstas tarp ASP skliausteliu.
%>
Kaip ir kiekvienoje programavimo kalboje (bet ne visose), eilutes skiriamos
kažkokiu skiriamuoju ženklu. PHP
kalboje eilutes skiriamos kabliataškiu. Pvz.:
<?php
echo 'Sveikas Pasauli';
echo "TESTAS TESTAS";
echo "Labas rytas";
?>
Taip pat šioje programavimo kalboje yra ir komentarai (comments). Komentuoti
savo skripto dalis galima
štai taip:
<?php
echo "Tai yra testas"; // Komentaras sakinio pabaigoje
/* Komentaras per kelias eilutes,
jo pagalba galite pakomentuoti detaliau */
echo "Tai kitas testas";
echo "Paskutinis testas"; # Štai cia dar vienas komentaro tipas
?>
3. Kintamieji ir kintamuju tipai
PHP palaiko štai tokius kintamuju tipus, kuriu jums turetu visiškai pakakti
kuriant jusu norima skripta:
· Integer; // sveikojo skaiciaus tipas
· Floating-point numbers; // slankaus kablelio skaiciai, arba kitaip - realieji
skaiciai
· String; // eilutes tipas
· Array; // strukturinio kintamojo tipas - masyvas
· Object; // objekto tipas (objektiniam programavimui)
Dažniausiai kitamojo tipas yra nustatomas ne paties programuotojo, o skripto
kompiliatoriaus. Jis pats
priskiria kintamajam tinkama tipa. Jei jums reikia keisti kintamojo tipa
programos metu, tai galite padaryti
naudodamiesi settype() funkcija.
Integer (sveikojo skaiciaus tipas)
Šis tipas priskiriamas kintamajam šiais atvejais:
$a = 1234; # dešimtainis skaitmuo
$a = -123; # neigiamas skaitmuo
$a = 0x12; # šešioliktainis skaiciaus pavidalas (lygus 18 dešimtaineje
sistemoje)
Floating-point numbers (slankaus kablelio skaiciai, arba kitaip realieji
skaiciai)
Štai du budai, vaizduojantys realuji skaiciu.
$a = 1.234;
$a = 1.2e3;
String (eilutes tipas)
String tipas gali buti vaizduojamas programavimo kalbose dviem budais:
1. tarp "viengubu" kabuciu pvz.: a$='Testas';
2. tarp "dvigubu" kabuciu pvz.: a$="Kitas testas";
Kaip C (C++) ir Perl'e, PHP naudoja štai tokius intarpus:
\n -nauja eilute
\\ - back slash'as
\$ - dolerio ženklas (nes paprastai su juo i stringa iterpiamas kintamasis)
\" - kabutes (kad su jomis neužbaigtumete savo stringo) Šiuo ženklu taip pat
galima pavaizduoti ir kitus
norimus simbolius.
Array (strukturinio kintamojo tipas - masyvas)
Vienmatis masyvas
Masyva galima isivaizduoti kaip viena ilga elementu seka, kurie susije savo
kintamuju tipais.
Pavyzdžiui, štai masyvas savaites dienos;
["pirm", "antr", "trec", "ketvr", "penkt", "sest", "sekm"]
$savdienos[0]="pirm";
$savdienos[1]="antr";
$savdienos[2]="trec";
$savdienos[3]="ketvr";
$savdienos[4]="penkt";
$savdienos[5]="sest";
$savdienos[6]="sekm";
Štai taip imanoma surašyti elementus i masyva savdienos.
PASTABA: atkreipkite demesi i tai, kad PHP masyvas prasideda nuo indexo [0], o
ne kaip
pascal'yje ar kitur nuo [1].
I vienmati masyva irašyti elementus galima ir šiuo budu:
$savdienos[ ]="pirm"; // 0 elementas
$savdienos[ ]="antr"; // 1 elementas
$savdienos[ ]="trec"; // ir t.t.
$savdienos[ ]="ketvr";
$savdienos[ ]="penkt";
$savdienos[ ]="sest";
$savdienos[ ]="sekm";
Masyvas gali buti rušiuojamas šiomis funkcijomis: asort(), arsort(), ksort(),
rsort(), sort(), uasort(),
usort(), ir uksort(). Placiau apie šias funkcijas skaitykite manual'e.
Taip pat per masyvo elementus imanoma "vaikscioti" štai šiomis funkcijomis:
next() ir prev()
Dvimatis masyvas (matrica)
Dvimatis masyvas vaizduojamas panašiai:
$skaicius[1][2] = $kitas; // dvimatis masyvas
Daugiamaciai (trimaciai ir t.t.) masyvai vaizduojami analogiškai:
$masyvas[1][2][3] = $kitas; // trimatis masyvas
Objekto tipas
Sukurti objekta ir veliau ji naudoti galima štai taip:
Class objektas
{
function parasyti()
{
echo "SVEIKAS PASAULI";
}
}
$naujas = & new objektas;
$naujas -> parasyti();
Programavimo kalbose yra du bjaurus dalykai - pointeriai ir referencai. pirmasis
tai lietuviškai verciasi
rodykle, o antrojo lietuvini pavadinima užmišau :] todel bus referencai.
aukštesnio lygio kalbose pointeriai
po truputi dingineja, o ju vieta keicia referencai. php jie taipogi yra. šiaip
tai viskas apie juos kaip ir apie
visa kitka geriausiai paaiškinta manuale.
php operatorius = kuria duomenu kopija, taipogi ir objektu, jei juos
priskyrinejam. php autoriai aiškina kad
jiems taip gaunasi greitesnis kodas. bet objektu dažniausiai nereikia kopijuoti,
o tik norime tureti kelis
vardus rodancius i ta pati objekta. todel jei nenorim kopijos, o tik nuorodos i
objekta: $object = &
$original_object;
netgi kuriant objekta su new: $obj = new Class(), $obj tera kopija pirminio
objekto gauto su new, todel
patartina prieš new deti & : $obj = & new Class(); ypac kai konstruktoriui
paduodamos kitos nuorodos.
PASTABA: kintamieji $kint ir $Kint yra visiškai skirtingi todel nesusipainiokite
juos naudodami.
4. Veiksmai su kintamaisiais
Kintamieji gali buti globalus ir lokalus. Pavyzdžiui:
$a = 1; /* globalus kintamasis */
function Testas ()
{
echo $a; /* lokalaus kintamojo spausdinimas */
}
Testas ();
Kaip manote, ka atspausdins ši funkcija? O gi nieko, kadangi funkcijoje
naudojamas lokalus kintamasis, o jis
vis dar nera apibrežtas. Pakeiskime pavyzdi, kad jis veiktu:
$a = 1; /* globalus kintamasis */
function Testas ()
{
global $a;
echo $a;
}
Testas ();
Dabar funkcija atspausdins reikšme 1.
Pirmame funkcijos variante yra sukuriamas statinis kintamasis, kuris funkcijai
baigus darba yra
sunaikinamas. Statini kintamaji galima aprašyti ir taip:
function Testas ()
{
Static $a = 0;
echo $a;
$a++;
}
Dabar vykdant funkcija yra sukuriamas statinis kintamasis, kuris yra
atspausdinamas ir padidinama jo
reikšme vienetu, taciau vos tik funkcija baigia savo darba, šis kintamasis yra
sunaikinamas.
Yra tokia savoka, kaip kintamojo kintamasis: Pvz.:
$sak = "Sveikas";
$$sak = "pasauli";
echo "$sak ${$sak}";
Ekrane pamatysime: Sveikas pasauli.
Pavyzdys su kintamuju veiksmais:
function double($i)
{
return $i*2;
}
$b = $a = 5; /* reikšme penkis priskiria kintamiesiems $a ir $b */
$c = $a++; /* kintamajam $c priskirima reikšme 6 (padidinta $a reikšme) */
$f = double($c++); /* funkcija double gražina reikšme du kartus didesne (return)
funkcijos reikšme bus
6*2=12 */
$c += 10; /* $c reikšme padidinama 10'cia */
$d=$a+$b; /* susumuoja */
Kitos operacijos su kintamaisiais:
$a + $b; //sumuoja
$a - $b; //atima
$a * $b; //daugina
$a / $b; //dalina
$a % $b; //randa moduli
Operacijos su eilutemis (string):
$a = "Sveikas";
$b = . "pasauli"; // po šio sakinio kintamasis $b bus lygus "Sveikas pasauli"
Loginiai operatoriai:
$a and $b; //teisinga jei abu reiškiniai teisingi
$a or $b; //teisinga jei nors vienas iš reiškiniu teisingas
$a xor $b; //teisinga kai kažkuris iš teiginiu teisingas bet ne abu kartu
!$a; //neigimas, ne $a
$a&&$b; //AND
$a||$b; //OR
Lyginimo operatoriai:
$a == $b; //teisinga jei lygu
$a != $b; //teisinga jei nelygu
$a < $b; //teisinga jei $a mažiau $b
$a > $b; //teisinga jei $a daugiau už $b
$a <= $b; //teisinga jei $a mažiau arba lygu $b
$a >= $b; //teisinga jei $a daugiau arba lygu $b
5. Duomenu (kintamuju) perdavimas iš formos skriptui
Padarykime paprasta mail'o siuntimo form'a (skripta). Mes naudosime paprasta PHP
funkcija mail(). Ka ši
funkcija daro
..Štai jos aprašymas:
mail($adress, $subject, $msg, "From: Nuo draugo.....");
Iš aprašymo turetu buti viskas aišku :) Ši funkcija išsiuncia laiška adresatui.
Mums lieka susikurt
kintamuosius ir ivykdyti funkcija. Pradžioje sukursime skripta mail.php3 , o
veliau ir forma, kurios pagalba
bus perduodami duomenys:
<?php
$address="jonas_jonaitis@centras.lt"; // cia adresas kur siunciat
$subject="Laishkas nuo: $from"; /* kintamaji $from skriptas ims iš formos */
mail ($address,$subject,$msg,"From: $from"); /* kintamasis $msg taip pat bus
imamas iš formos */
?>
Štai ir sukureme skripta. Jums lieka ji išsaugot vardu mail.php3. Dabar mums
reikia sukurti forma, iš kurios
bus siunciamas laiškas. Cia ir sužinosite kaip kintamieji per forma perduodami
skriptui (elementarus, lengvas
dalykas) . Mums reikia sukurti forma su dviem laukais: nuo ko laiškas ir laiško
turinys. Taip ir padarysime:
<FORM METHOD="POST" ACTION="mail.php3">
<I>- Iveskite duomenis:</I><BR>
<INPUT TYPE="text" size="20" NAME="from"><BR>
<TEXTAREA NAME="msg" ROWS="3" COLS="20"> </TEXTAREA> <BR>
<INPUT TYPE="Submit" NAME="Ok" VALUE="Išsiusti">
</FORM>
Štai ir viskas. Daugiau nieko daryti jums nebereikia. Juk taip paprasta?
Kintamieji from ir msg automatiškai
bus perduodami i skripta, o funkcija mail() juos panaudos.
Kam naudotis kažkieno padarytais skriptais? Taigi visai paprasta norima skripta
pasidaryti paciam, pagal
save. O tai atlikti galite tikrai labai nesunkiai ir per trumpa laiko tarpa.
Panašiai yra ir su adresiniu duomenu perdavimu. Tarkime mums reikia, kad i
administravimo skripta ateitu
duomenys username ir pasword. Tai galima padaryti kreipdamiesi i skripta tokiu
pavidalu:
http://www.tarambaram.lt/darkasnors/admin.php3?user=jonas&pswd=jonaitis Tada
skripte admin jus
gaunate kintamuosius $user ir $pswd ir galite juos sutikrinti su jusu norimais.
5.1 Placiau apie funkcija mail()
5.1.1 php.ini konfiguravimas
Visu pirma norejau atkreipti visu demesi, kad dažniausiai jei jus testuojates po
Windows platforma jums
mail() funkcija neveiks. Neveiks todel kad php.ini faile pagal nutylejima SMTP
serveris nurodytas localhost,
o didžiausia tikymybe yra ta kad pas jus po localhost SMTP serverio nera (nebent
sedite po Windows
Server), todel savo ekrane matysite tik štai toki užraša: Warning: Failed to
Connect in
c:\kelias\kelias\failas.php on line XX. Štai tai apie ka jums ir sakiau: php
negali prisijungti prie SMTP
serverio.
To galite išvengti iraše php.ini faile SMTP=jums_žinomas_smtp_serverio_adresas.
Jei pas jus PHP ne kaip
CGI neužmirškite restartuoti Apache serverio.
5.1.2 Pradmenys
taigi, ka daro mail() funkcija? mail() funkcija leidžia jums siusti el.pašta
tiesiai iš jusu kodo. Ji dažniausiai
naudojama kontaktu, registravimo formose. Kai tam tikru meil'u norima informuoti
apie užpildyta forma. Bet
pritaikymo budu yra begale.
bool mail(string to, string subject, string message [, string additional_headers
[, string
additional_parameters ])
mail funkcija gražina boolean tipa (true/false). Jei mail funkcija gražina false
reiškia el. pašto išsiusti
nepavyko. Štai kaip siunciamas paprasciausias el.paštas:
<?php
mail('webmaster@php.lt','Cia norima tema (subject)','Ir einanti žinute');
?>
Taigi kaip matote pirmasis mail argumentas, tai el. pašto adresas kuriam
siunciate el.pašta, paskui eina
Subject'as (norima tema), o po subject'o ir žinutes tekstas. Žinutes texte
norint nukelti teksta i nauja
eilute iterpkite \n (new line|nauja eilute), pvz.:
<?php $tekstas = "mano žinute\n\nNikolajus Krauklis\naka DzHiBaS";?>
Po žinutes gali eiti papildomi parametrai: headeriai, bei kiti papilomi
parametrui sendmail'ui ir t.t.
Tik išsiuntus ši el. pašta pastebesite kad el.žinuteje nera (kaikuriu)
lietuvišku raidžiu. Ju nera del
netinkamos el.žinutes koduotes. Žinutes koduote yra nustatoma žinutes headeryje
(antrašteje).
5.1.3 Antraštes (headeriai)
pastaba: žinutes antraštes yra atskiriamos "\r\n".
headeriuose galima nurodyti daug idomiu bei naudingu dalyju: nuo ko siunciamas
laiška, laiško koduote,
reply-to laukas, meileris, bcc ir t.t. Štai pavizdys paprasciausio headerio
kuris turetu buti kiekviename
laiške:
<?php
$header = "Content-type: text/plain; charset=\"windows-1257\"\r\n";
$header .= "From: Nikolajus Krauklis <mano@el_pastas.lt>\r\n";
$header .= "Reply-to: mano@el_pastas.lt\r\n";
mail('webmaster@php.lt','Cia norima tema (subject)','Ir einanti
žinute',$header);
?>
Content type nurodome kad žinute bus plain tekstu (ne HTML) bei windows-1257
charset'u. Išsiuntus
laiška su šiuo headeriu esu isitikines kad windows vartotojai gaus jusu išsiusta
el.žinute su visom
lietuviškom raidem.
From headeryje nurodome nuo ko siunciamas laiškas. Siuntejas/gavejas gali buti
norodomas štai tokiais
formatais:
<?php
/*
* paste iš kažkokio RFC susijusio su meil'ais
*
* From: mark@cbosgd.UUCP
* From: mark@cbosgd.UUCP (Mark Horton)
* From: Mark Horton <mark@cbosgd.UUCP>
* From: "Mark Horton" <mark@cbosgd.UUCP>
*/
?>
Reply-to tikriausiai jau patys supratote kam reikalingas? Pagal nutylejima jei
nera reply-to jusu meil'eris
darys reply asmeniui kuris atsiunte ši laiška, bei jei yra reply-to, paspaudus
meileryje (outlook'e, bat'e,
mutt'e ir t.t.) reply, tai to: lauke atsiras reply-to el.pašto adresas.
Štai dar papildomi headeriai kurie gali praversti:
<?php
$headers .= "X-Mailer: mano PHP meileris\r\n"; // maileris
$headers .= "X-Priority: 3\r\n"; // žinutes tipas: 1 UrgentMessage, 3 Normal
$headers .= "Return-Path: <mail@server.com>\r\n"; //kur gražinti meila ištikus
klaidai
mail('webmaster@php.lt','Cia norima tema (subject)','Ir einanti
žinute',$headers);
?>
X-Mailer - tai niekur nedominuojantis headeris. Priority - dažnai pastebite kad
buna žinutes su šauktuku
šone, ten žymimi prioritetai. jei uždesite prioriteta 1 - tai reiškia žinute yra
auksciausio prioriteto ir prie
el.žinutes gavejo el.pašto programoje atsiras raudonas šauktukas. Dažniausiai
visi siuncia el.žinutes su 3
(normaliu) prioritetu.
Return-path - tai el.pašto adresas i kuri bus nukreipiamos visos klaidas (pvz.:
el.žinute nepasieke reikiamo
nusmigusio serverio, arba tokio el.pašto adreso adresas jau nebeegzistuoja
sistemoje)
Kaip nusisiusti el.žinutes kopija sau? Yra tris galimybes:
1. pats paprasciausias tai nurodyti to lauka štai taip:
<?php
$to = "Kažkoks vartotojas <pvz@pvz.lt>" . ", ";
$to .= "Nikolajus Krauklis <webmaster@php.lt>";
mail($to,'Žinute dviems gavejams','Tekstas');
?>
2. savo el.pašto adresa nurodyti Cc headerio lauke:
<?php
$header .= "cc: webmaster@php.lt\r\n";
?>
Šiuo atveju visi gavejai matys kam buvo siunciamas gautas el.paštas.
3. Naudotis headerio Bcc lauku:
<?php
$header .= "bcc: webmaster@php.lt\r\n";
?>
dabar gavejai niekaip nepastebes kad meil'o kopija buvo siusta ir man!!! :)
5.1.4 Conclusion
na va berods viska ir išaiškinau. Norejau pridurti ir tai kad el.žinutes gali
buti siunciamos ir HTML formatu,
tada headeris atrodytu taip:
<?php $header = "Content-type: text/plain; charset=\"windows-1257\"\r\n";?>
Dabar el. žinuteje galite naudoti ir HTML tagus (pastaba: ne visi meileriai turi
galimybe rodyti el.žinutes
HTML formatu).
Gal pravers šie dokumentai: » RFC 1896, » RFC 2045, » RFC 2046, » RFC 2047, »
RFC 2048, ir » RFC 2049.
Jei jums reikia straipsnio kuriame aiškinama apie MIME el. pašto formata bei jo
headerius apsilankykite
Zend'e.
6. Duomenu (kintamuju) atejusiu iš formos patikrinimas
Dažnai tenka susidurti su tokia problema kaip vandalizmu internete. Žmones bando
apeiti formu pildymus,
duoda "netikrus" el. pašto adresus ir t.t. Yra priemoniu nuo to apsisaugoti.
Visu pirma reiktu riboti žinutes ilgi. Kad nenaudeliai neprirašytu šiukšliu. Tai
galima padaryti taip:
<INPUT TYPE="text" size="20" NAME="from" maxlength="30"><br>
<TEXTAREA NAME="msg" ROWS="3" COLS="20" maxlength="500"> </TEXTAREA>
maxlength - leidžia ivesti vartotojui tik limituota simboliu skaiciu.
E-mail'as be abejo gali buti nesamoningas, todel padarysime maža skriptuka,
kuris patikrina ar e-mail'as
parašytas teisingai. Dabar išnagrinesime pati paprasciausia atveji, kai
vartotojas neiveda e-mail'o:
Tam mes naudosim funkcija empty( ); Ji tikrina ar kintamasis nera tušcias (ar
jam yra priskirta kokia nors
reikšme)
if (empty($from))
{
echo "Jus neivedete savo e-mailo";
}
Iterpkite ši gabaliuka i mail.php ir jus jau turesite apsauga nuo tušcio from
laukelio. Be abejo žmogus gali i
laukeli iveti bet ka, tada bus apeita ši apsauga. Kad taip neatsitiktu,
patikrinsime ar irašytas e-mail'as turi
savyje simboli "@":
Naudosime paprasta string funkcija: int strrpos(string haystack, char needle);
Ji randa ieškomo simbolio
pozicija eiluteje:
function ar_yra_eta() /* Funkcija, kuri patikrina ar kintamajame $from yra "@"
*/
{
global $from; /* $from padarome globaliuoju kintamuoju */
$pos = strpos($from, "@"); /* i kintamaji $pos irašoma pozicija kurioje stovi
"@" */
if (!$pos) /* Pažiurime ar apskritai yra "@" e-meile */
{
return false; /* Gražina funkcijos reikšme false jei "@" nera emeile */
}
else
{
if ($pos!=0 && $pos!=1)
{ /* Apsaugome, kad nebutu pavyzdžiui toks meilas ( a@centras.lt arba
@centras.lt) */
return true; /* Jei viskas tvarkoj gražina funkcijos reikšme true. */
}
}
}
Štai padareme funkcija, kuri apsaugo nuo e-mail'o be simbolio "@".
Taip pat galime tikrinti, ar i skripta duomenys atsiunciami POST metodu. Pvz. iš
HTML dokumento:
<form method=post action=kazkas.php>
Pavyzdys iš kazkas.php skripto:
if ($REQUEST_METHOD == "POST")
{
// kazka darom
}
else echo "Klaida! Metodas turi buti POST!";
Taip apsisaugosite nuo GET metodu perduodamu kintamuju, pvz.
kazkas.php?vardas=siaubas&mailas=betkoks&kazkas=asdasd...
7. Darbas su data ir laiku
Darbui su data PHP turi savo funkcija date(formatas). Tai gana patogi funkcija.
Funkcija naudojama laiko
ir datos gavimui ivairiais formatais.
Formatai:
· Y - metai,pvz.: 1997
· y - metai,pvz.: 97
· M - menuo, pvz.: Oct
· m - menuo, pvz.: 10
· D - savaites diena, pvz.: Fri
· l - savaites diena, pvz.: Friday
· d - diena, pvz.:27
· z - metu diena, pvz.: 299
· H - valandos 24 val. formatu
· h - valandos 12 val. formatu
· i - minutes, pvz.: 5
· s - sekundes, pvz.: 40
· a - am/pm
programu pavyzdžiai:
$date = date('d M Y'); // I naršykles ekrana išves: 22 Nov 1999
$date = date('H:i:s'); // I naršykles ekrana išves: 20:24:30
$date = date('d M Y, H:i:s'); // I naršykles ekrana išves: 22 Nov 1999, 20:29:42
Bet dažnai mums reikia ne angliškos datos puslapyje, o lietuviškos. Kaip
sulietuvinti data? Skripto
pavyzdys:
<?php
function data_lt()
{
$menesis = date('n');
$mas_menesiai = array("Sausio", "Vasario", "Kovo", "Balandžio", "Gegužes",
"Birželio",
"Liepos","Rugpjucio", "Rugsejo","Spalio", "Lapkricio", "Gruodžio");
$data = date('Y ');
$data .= $mas_menesiai[$menesis-1];
$data .= date(' j \d.');
return $data;
}
echo data_lt();
?>
Skriptas išves i ekrana 2002 menesis diena d., pvz. 2002 Balandžio 7 d.
8. Veiksmai su failais
Anksciau (taciau ir dabar dažnai sutinkamas) vienas iš pagrindiniu budu saugoti
duomenis, buvo laikyti juos
paprastame faile. Duomenys buvo skaitomi iš failo ir rašomi i faila, kol
neatsirado greitesnis budas - DB
(duomenu bazes). Nors duomenu baziu vartojimas vis populiareja, failu skaitymas
ir rašymas i juos yra
naudingi.
Pagrindines funkcijos skaitymui bei rašymui: fopen(), fgets(), fputs(),
fclose(), feof(); Ju pilnai pakanka
dirbui su failais.
fopen()
fopen - atidaro faila (skaitymui, rašymui arba papildimui). fopen(string
failo_vardas, string mode); mode -
kokiai "sesijai" atidaryti faila. O "sesijos" yra štai tokios:
'r' - atidaro faila tik skaitymui, pointeri pastato failo pradžioje,
'r+' - atidaro faila skaitymui ir rašymui, pointeri pastato failo pradžioje,
'w' - atidaro faila rašymui, pointeri pastato failo pradžioje, failo dydi
nunulina (ištrina visus buvusius
duomenis), o jei failas neegzistuoja - sukuria ji,
'w+' - atidaro faila skaitymui ir rašymui, pointeri pastato failo pradžioje,
faila nunulina, o jei failo nera ji
sukuria iš naujo.
'a' - atidaro faila tik rašymui, pastato pointeri i failo pabaiga, jei failas
neegzistuoja - sukuria ji,
'a+' - atidaro faila ir skaitymui ir rašymui pastato pointeri i failo pabaiga,
jei failas neegzistuoja - sukuria
ji.
Pavyzdžiai:
$fp = fopen("/home/kazkas/file.txt", "r");
$fp = fopen("http://www.php.lt/", "r");
$fp = fopen("ftp://user:password@pvz.lt/", "w");
Atidarius faila, atlikus savo veiksmus, butinai reikia ji uždaryti pasinaudojus
funkcija fclose();
Pvz.:
fclose($fp);
fputs(); - irašo duomenis i faila,
fgets(); - nuskaito nurodyto ilgio eilute i string tipo kintamaji,
$string = fgets($fp,255); // nuskaito visa eilute
Paprastas pavyzdys:
$fp = fopen("/tmp/inputfile.txt", "r");
while ($bufferis = fgets($fp, 4096)) {
echo $bufferis;
}
fclose($fp);
Nuskaito visas failo eilutes ir išveda i ekrana. Bet cikla galime pakeisti
paprastesniu:
$fp = fopen("/tmp/inputfile.txt", "r");
while (!feof($fp)) {
$bufferis = fgets($fp, 4096)
echo $bufferis;
}
fclose($fp);
Dabar ciklas vykdomas tol, kol prieinama failo pabaiga.
Padarykime paprasciausia puslapio skaitliuka, kad pamatytume kaip gi ištiesu
veikia aukšciau aprašytos
funkcijos:
<?php
$filename = "skaitlius.dat"; /* Priskiria kintamajam failo pavadinima */
$fp = @fopen($filename,"r"); // Atidaro faila skaitymui
if ($fp) { /* Jei failas atidarytas vykdomas salygos sakinys */
$counter=fgets($fp,10); /* I kintamaji nuskaitoma skaitliuko reikšme */
fclose($fp); // Uždaromas failas
} else {
$counter=0; /* Jei failo nebuvo skaitliui priskiriama nulis */
}
$counter++; /* Padidinama skaitliuko reikšme vienetu */
echo $counter; // Išspausdinama reikšme
$fp = fopen($filename,"w"); /* Ir toliau i faila idedama nauja skaitliuko
reikšme padidinta vienetu. */
if ($fp) {
$counter=fputs($fp,$counter);
fclose($fp);
}
?>
Štai taip paprastai jus galite pasidaryti savo puslapio skaitliuka. Man iškilo
toks klausimas :/ O jeigu
puslapis labai dažnai lankomas ir butent tuo paciu momentu ateina du lankytojai.
Pirmasis lankytojas faile
nuskaito (pvz.: skaitliuko reikšme) o kitas irašo. Kas tada? O gi tada kyla
gresme prarasti skaitliuko reikšme
faile, kadangi negalima tuo paciu metu ir skaityti ir rašyti i faila. Kad tai
išprestume, galime naudoti viena
funkcija flock(). Ši funkcija laikinai sustabdo antro vartotojo darba ir
palaukia kol pirmasis baigs darba su
failu, tada antrajam vartotojui leidžiamas darbas su tuo failu. Patariama kuo
dažniau vartoti šia funkcija
dažnai lankomuose puslapiuose!!!
Pavyzdys:
$failas = @fopen('skaitlius.dat','r');
flock = ($naujas_failas,2);
$count = fgets($file, 255);
$count++;
flock = ($naujas_failas,3);
fclose($file);
Šiuo atveju jus esate apsaugoti nuo galimo konflikto su failu.
Dauguma iš musu padeje mokintis PHP tikrai nepradejome nuo PHP+SQL ar Oracle. Be
to, gal ne kiekvienas
turi serveri su duombazes palaikymu. Aš pats asmeniškai mažiausiai puse metu
"vargau" su tekstiniais
failais. Kuri laika man to tikrai pakako pakeisti duomenu baze.
8.1. Informacijos perskaitymas iš tekstinio failo. Pritaikymas: counter'io
rezultato bei ištisinio teksto
nuskaitymas ir pan.
<?php
$failas="duomenys.txt";
$duomenys = fopen($failas, "r");
$informacija = fread($duomenys, filesize($failas));
fclose($duomenys);
echo $informacija;
?>
8.2. Naujas irašymas ištrinant visus senus duomenis. Pritaikymas: paprasto
counter'io skaiciaus irašymas ir
pan.
<?php
$informacija="Tekstas, irašomas i faila";
$failas="duomenys.txt";
$duomenys=fopen($failas, "w");
fwrite($duomenys, "$informacija");
fclose($duomenys);
?>
8.3. Irašymas neištrinant senu duomenu, o tesiant saraša toliau. Pritaikymas:
ivairus log'ai ir pan.
<?php
$informacija="Tekstas, irašomas i faila";
$failas="duomenys.txt";
$duomenys=fopen($failas, "a");
fwrite($duomenys, "$informacija\n");
fclose($duomenys);
?>
8.4. Tekstine duomenu baze. Informacijos eilutes perskaitymas iš tekstinio
failo.
Pritaikymas: objekto aprašymas, jei objektas turi daugiau nei savybe
Pvz.: Mindaugas|20|185|70
Pateikta eilute apibudina asmens varda, amžiu, ugi ir svori.
Taigi, duomenys.txt struktura turi buti tokia:
tekstas0|tekstas1|tekstas2|tekstas
Kodo fragmento esme tokia, kad yra perskaitoma eiluteje surašyta informacija ir
išskirstoma i atskirus
atitinkamus kintamuosius $laukelis[$i]. Šiuo budu jau imanoma sukurti panašia i
duomenu bazes lentele.
<?php
$failas="duomenys.txt";
$simboliu_skaicius = count($failas);
$stulpelis = file($failas);
for($i=0; $simboliu_skaicius > $i; $i++){
$laukelis = explode("|", $stulpelis[$i]);
}
echo "$laukelis[0] $laukelis[1] $laukelis[2] $laukelis[3]";
?>
Kaip irašyti duomenis i faila, galite perskaityti skyriuje 2.
Tik kintamasis $informacija turetu buti $informacija="Mindaugas|20|185|70";
8.5. Daug tekstiniu eiluciu. Pilnos duomenu bazes struktura.
Pvz.:
Mindaugas|20|185|70
Kristina|20|174|50
Rimantas|50|190|80
[..]
Vaida|19|171|53
duomenys.txt failo sukurimas yra paprastas:
<?php
$vardas="vardas";
$amzius="amzius";
$ugis="ugis";
$svoris="svoris";
$informacija=$vardas."|".$amzius."|".$ugis."|".$svoris;
$failas="duomenys.txt";
$duomenys=fopen($failas, "a");
fwrite($duomenys, "$informacija\n");
fclose($duomenys);
?>
9. REMOTE_HOST ir REMOTE_ADDR
Ar jums idomu kas lanko jusu puslapi? Manome, kad taip! Todel skriptas, kuris
atlieka loginima buvo, yra ir
bus visada akltualus. O tai nera labai sunku. Pasinaudojus štai tokiomis
nesunkiomis funkcijomis :
Getenv("REMOTE_HOST");
ir
Getenv("REMOTE_ADDR");
Mes galime sužinoti kompiuterio hosta ir IP adresa iš kurio buvo peržiurinetas
puslapis.
$host = getenv('REMOTE_HOST');
$ip = getenv('REMOTE_ADDR');
Štai taip sužinome nutolusio kompiuterio duomenis. Lieka tik išsaugoti visa tai
faile, kuris ir bus jusu
puslapio lankytoju logas. Faila dar papildysime data:
<?php
$filename= "log.dat";
$fp = @fopen($filename,"a+");
$host = gethostbyaddr($REMOTE_ADDR);
$ip=getenv('REMOTE_ADDR');
$date=date('d M Y, H:i:s');
$str = (" Data: $date \n IP adresas: $ip \n Host\'as: $host \n
---------------------------------------
\n ");
fputs($fp,$str);
fclose($fp);
?>
Faile log.dat bus išsaugota kažkas panašaus i tai:
Data: 24 May 2000, 22:59:23
IP adresas: 000.000.000.000
Host: host.vu.lt
---------------------------------------
Data: 24 May 2000, 23:03:03
IP adresas: 000.000.000.000
Host: host.ktu.lt
---------------------------------------
Data: 24 May 2000, 23:04:16
IP adresas: 000.000.00.00
Host: host.ku.lt
---------------------------------------
10. Cookies
"Cookiai" yra dažnai vartojamas "daiktas". Tai mechanizmas, kuris saugo duomenis
nutolusiame
kompiuteryje. Tarkime, mums reikia žinoti kada žmogus paskutini karta buvo musu
puslapyje. Tai imanoma
padaryti pasinaudojus "cookiais". Nustatyti "cookius" galima pasinaudojus PHP
funkcija SetCookie().
"Cookiai" yra puslapio header'io ("galvos") dalis, todel SetCookie funkcija turi
buti panaudota prieš bet
kokius duomenu siuntimus naršyklei (browseriui).
Pvz.:
SetCookie ("ManoCookis[ ]", "Testas", time()+3600);
Jei norite iterpti kelias reikšmes tiesiog pakartokite šia funkcija, bet jei
"cookiu" vardai sutaps, bus pakeista
tik reikšme (replace) Jei norite naudoti savo pavadinimus pvz.: pask_buvo, tai
iterpkite tai vietoj
ManoCookis[ ].
Tarkime, mums reikia sukurti elektronines parduotuves vežimeli. Jame bus saugoma
informacija apie tai, kiek
prekiu vežames ir visi ju pavadinimai:
$Kiek_prekiu++;
SetCookie ("Kiek", $Kiek_prekiu, time()+3600);
SetCookie ("Preke[$Kiek_prekiu]", $prekes_pav, time()+3600);
Štai taip atrodys skripto dalis.
"Cookiu" gyvavimo laikotarpis nusistato taip (tarkime mums reikia, kad musu
"cookiai" gyvuotu penkias
dienas):
$k_gyvena = 5 * 24 * 3600; /* Gyvavimo laikotarpis nusistato sekundemis; */
SetCookie ("Kiek", $Kiek_prekiu, time()+$k_gyvena);
11. Ciklai
Jei ne ciklai, programavimas butu gana nuobodus užsiemimas. Ciklas, tai
priemone, kurios pagalba galima
vykdyti koda nurodyta skaiciu kartu arba tol, kol nebus ivykdyta kokia nors
salyga. PHP kalboje yra du ciklu
tipai: while ir for. Ciklai while tikrina salygas prieš arba po kiekvieno ciklo
pakartojimo ir kartoja cikla tik tuo
atveju, jei salyga vis dar netenkinama. Cikle for, prieš pirma ciklo
pakartojima, nurodomas ciklo kartojimu
skaicius, kuris negali buti keiciamas ciklo vykdymo metu.
Ciklas while
Šio ciklo sintakse panaši i operatoriaus if sintakse.
while(salyga) {
...kodas...
}
Ciklo while salyga yra loginio tipo. Jeigu ji igija reikšme false, tai kodas
parašytas rietiniuose skliaustuose
praleidžiamas. Jei true - kodas riestiniuose skliaustuose vykdomas. Pasiekus
ciklo uždarymo skliausta },
reikšme vel tikrinama ir, jei ji teisinga ciklas kartojamas. Tokiu budu ciklas
yra kartojamas tol, kol [vykdoma
salyga. Atkreipkite demsi i tai, jog salyga yra tikrinama kiekvieno ciklo
pakartojimo pradžioje, todel jei
salyga bus pateinkinta jau kodo viduryje, tai kodas bus vis tiek vykdomas iki
galo. Norint nutraukti ciklo
darba prieš laika naudokite operatoriu break.
$i=11;
while(--$i) {
if(mano_funkcija($i) == "error") {
break; //sustabdyti cikla
}
++$kinamasis;
}
Jeigu numanoma mano_funkcija() funkcija, duotame pavyzdyje, neduos jokios
klaidos, tai ciklas bus
kartojamas dešimt kartu, tol, kol $i reikšme bus lygi nuliui (priminimas: nulis
gražina reikšme "false"). Jei
funkcija mano_funkcija() gražina klaida, ivykdomas operatorius break ir ciklas
sustabdomas. Taciau kartais
tereikia prašokti viena ciklo kartojima ir prieiti prie kito, nestabdant paties
ciklo. Tam naudojamas
operatorius continue.
$i=11;
while(--$i) {
if(mano_funkcija($i) == "error") {
continue; //pereiti prie kito ciklo kartojimo, nepadidinant $kintamasis
reikšmes.
}
++$kinamasis;
}
Šis kodas taip pat yra vykdomas dešimt kartu, jei mano_funkcija() negražina
klaidos. Taciau priešingu
atveju ciklas nera stabdomas, o yra pereinama prie kito pakartojimo,
nepakeiciant $kintamasis reikšmes.Jei
po to $i reikšme vis dar nelygi nuliui, ciklas kartojamas kaip iprasta.
Ciklas do...while
Ciklas do...while analogiškas while, taciau salyga cia tikrinama ne pradžioje,
bet pabaigoje kiekvieno
pakartojimo. Tai reiškia, kad ciklas bus kartojamas bent viena karta:
echo("<SELECT name='dalys'>\n");
$i=0;
do {
echo ("\t<OPTION value=$i>$i</OPTION>\n");
} while (++$i < $kiekis);
echo("</SELECT>\n");
Vykdant ši koda nulis bus išvedamas visada, kaip vienas iš pasirinkimu. Kitu
pasirinkimu skaicius priklausys
nuo $kiekis reikšmes.
Ciklai while ir do...while dažnai naudojami kartu su inkrementacijos(padidinimo
vienetu) ir
dekrementacijos(sumažinimo vienetu) operatoriais, siekiant nurodyti ciklo
kartojimu skaiciu. Operatoriai
while taip pat dažnai naudojami skaitant duomenis iš duomenu bazes, eilutes iš
failu, elementus iš
masyvu(bet apie tai veliau).
Ciklas for
Ciklo for sintakse yra šiek tiek sudetingesne nei while, taciau kartais naudoti
for daug naudingiau.
for($i=1; $i<11; ++$i) {
echo("$i <br> \n"); // išvedami skaiciai nuo 1 iki 10
}
Ciklo for skliausteliuose nurodomi trys išsireiškimai, atskiriami
kabliataškiais. Pirmuoju iš ju priskiriama
reikšme ciklo kintamajam. Šis išsireiškimas vykdomas tik prieš pirma ciklo
pakartojima. Kitas išsireiškimas yra
loginio tipo, ir yra tikrinamas kiekvieno ciklo pakartojimo pradžioje. Jei šio
išsireiškimo reikšme yra true,
ciklas yra kartojamas, jei false, ciklo vykdymas sustabdomas. Treciasis
išsireiškimas vykdomas kiekvieno
ciklo pakartojimo gale ir dažniausiai naudojamas ciklo kintamojo padidinimui
arba sumažinimui.
Vidurinis išsireiškimas dažniausiai palygina ciklo kintamaji su kokia nors
anksciau nustatyta reikšme, taciau
taip yr nevisada. Pavyzdyje pateiktas kiek kitokio panaudojimo pavyzdys.
for($i=1; mano_funkcija($i) != "klaida"; ++$i) {
// vykdomas kodas, kol mano_funkcija() negražina klaidos
}
Ta pati galima padaryti ir su ciklu while.
$i=1;
while (mano_funkcija($i) != "klaida") {
// vykdomas kodas, kol mano_funkcija() negražina klaidos
++$i;
}
Nera tokios užduoties, kuria butu galima atlikti su ciklu for, bet negalima
atlikti su while. Taciau dažniausiai
ciklas for atrodo daug kompaktiškesnis ir labiau organizuotas.
Kaip ir kitose i C panašiose kalbose, PHP yra leidžiama (nors sutinkama retai)
palikti viena ar daugiau iš triju
minetu išsireiškimu tušciais.
for( ; ; ) {
if(mano_funkcija() == "stop") break;
}
Jeigu loginis išsireiškimas yra tušcias, tai pagal nutylejima jis gražina true.
Tai gali salygoti ir begalinio ciklo
atsiradima, jei nenaudosime break, return arba exit. Be abejo, pagrindas tam,
kad nenaudoti kurio nors iš
išsireiškimu cikle for, atsiranda retai.
12. Salygos operatoriai
Šioje pamokoje aptarsime PHP kalboje egzistuojancius operatorius, kurie sudaro
programos griaucius.
Salygos operatoriai ir ciklai padeda išpresti daug užduociu.
Salygos operatoriai
Salygos operatoriai leidžia rašyti koda, kuris bus vykdomas tik esant kažkokioms
salygoms. PHP kalboje yra
dvi salygines konstrukcijos. Pirmoji iš ju yra if...elseif...else, leidžianti
patikrinti keleta išsireiškimu ir vykdyti
koda, priklausomai nuo tu išsireiškimu reikšmes. Jeigu reikia palyginti viena
išsireiškima su keletu reikšmiu,
tai PHP leidžia naudotis konstrukcija switch....case, atliakancia šia užduoti.
Operatorius if
Operatorius if yra viena iš svarbiausiu galimybiu visose programavimo
kalbose.Jis leidžia vykdyti tam tikras
kodo eilutes, tik esant nurodytoms salygoms. Operatoriaus if sintakse:
if (salyga) {
....kodas...
}
Jeigu salygos sakinyje vykdome daugiau nei viena kodo eilute, koda reikia
apskliausti riestiniais skliaustais.
Jei vykdome tik viena eilute, to daryti nera butina.
// šis kodas išves "Lietuva.", jei kinamojo $salis reikšme bus "lt".
if ($salis == lt)
echo(Lietuva.);
// šis kodas išves "Lietuva. Jos sostine - Vilnius", jei kinamojo $salis reikšme
bus "lt".
if ($salis == lt) {
echo(Lietuva. );
echo("Jos sostine - Vilnius");
}
Operatoriuje if tikrinama salyga turi tureti loginio tipo(boolean) reikšme true
arba false. Bet kokia
neivykdoma salyga, nulis, tušcia eilute, nenustatytas dydis ir PHP konstanta
false turi reikšme false.
Pavyzdžiui, visi žemiau pateikti išsireiškimai tures reikšme false:
if (5<4) echo ("Tai nebus išvesta");
if (false) echo ("Tai nebus išvesta"); //false yra PHP konstanta
if ("0") echo ("Tai nebus išvesta"); //Apdorojant eilutes, "0" virsta 0
if ($g) echo("Tai nebus išvesta"); //Tuo atveju jei $g nera priskirta reikšme
Dydis true yra ekvivalentus bet kokiai reikšmei, nelygiai nuliui, tušciai
eilutei, svarbu kad salyga bšti
patenkinta. Žemiau pateikti išsireiškimai igyja reikšmes true:
if ("false") echo ("Tai bus išvesta); // false jau yra nebe konstanta, o eilute
if ("00") echo ("Tai bus išvesta); // eilute iš dvieju nuliu nera perdirbama i
sveikojo tipo reikšme
if (0 ==0) echo ("Tai bus išvesta); // nulis lygus nuliui, todel salyga
patenkinta
Taciau salygas galima padaryti ir sudetingesnes, apjungiant kelias salygas
loginiais operatoriais.
if (((4<5) && (3>2)) xor (5 == 5)) echo (Tai išvesta nebus); // teisingos abi
salygos, apjungtos
operatoriusmi xor, todel viso išsireiškimas neteisingas
Paneigtos salygos
Jeigu tikrinama salyga gražina false, tai PHP leidžia nurodyti kita kodo bloka,
kuris bus vykdomas,
panaudojant else sakini. Pavyzdžiui:
if ($k < 0) {
echo (Neigiamas skaicius);
} else {
echo (Teigiamas skaicius);
}
Duotasis sakinys tikrina, ar kintamojo reikšme mažesne už nuli. Jei taip, tai
išvedama Neigiamas sakicius.
Jei yra priešingai, išvedama Teigiamas skaicius. Egzistuoja sakinys elseif,
leidžiantis patikrinti
alternatyvias salygas. Pvz.:
if ($k < 0) {
echo (Neigiamas skaicius);
} elseif ($k ==0) {
echo (Nulis);
} else {
echo (Teigiamas skaicius);
}
Pavyzdyje pateikta konstrukcija tikrina, ar kintamojo reikšme mažesne už nuli.
Jei taip, parašoma, jog tai
neigiamas kaicius. Jei nepatenkinama pirmoji salyga, tikrinama, ar kintamais
lygus nuliui. Jei taip, parašoma
jog tai nulis. O jeigu nepatenkinama nei viena iš ankstesniu salygu, parašoma,
jog tai teigiamas skaicius.
Operatorius switch
Tarikime, jog turime kintamaji $salis, kuriame yra saugomas sutrumpintas
valsybes pavadinimas, taciau mes
norime išvesti pilna tos šalies pavadinima. Jei darba atliktume su konstrukcija
if...elseif....else, tai atrodytu
maždaug taip:
if ($salis== ca) {
echo (Kanada);
} elseif ($salis == cr) {
echo (Kosta Rika);
} elseif ($salis == de) {
echo (Vokietija);
} elseif ($salis == uk) {
echo (Didžioji Britanija);
} else {
echo(JAV);
}
Šiame pavyzdyje, mes kiekviena karta lyginome kintamaji $salis su tam tikra
reikšme ir priklausmai nuo to,
išvesdavome reikšme. Tai yra pakankamai neefektyvu. Tai galima ištaisyti,
naudojant konstrukcija
switch/case. Operatorius switch naudojamas tada, kai reikia viena kintamaji
palyginti su keliomis
reikšmemis.
switch($salis) {
case ca :
echo (Kanada);
break;
case cr :
echo (Kosta Rika);
break;
case de :
echo (Vokietija);
break;
case uk:
echo (Didžioji Brotanija);
break;
default:
echo (JAV);
}
Operatorius switch ima reikšme iš kintamojo $salis ir lygina ja su reikšmemis
pateiktomis case sakiniuose.
Kai randama sutampanti reikšme, vykdomas kodas, kol randamas operatorius break.
Jei nera sutampanciu
reikšmiu vykdomas default sakinyje parašytas kodas.
Na, o dabar smulkiau panagrinesime operatoriu break. Jis leidžia sustabdyti
operacijas case operatoriuose.
Jei $salis reikšme yra cr, tai išvedama "Kosta Rika", ir operatorius break
sustabdo tolesni vykdyma. Jei
break neegzistuotu, programa butu vykdoma toliau ir i ekrana butu išvesti visu
likusiu valstybiu
pavadinimai. Tai gali buti naudinga, bet gali ir pakenkti. Musu atveju, tai
pakenke. Taciau šia problema gali
mums padeti išspresti kita užduoti:. mes galime apjungti kelis operatorius case
ir jei bent vieno iš ju reikšme
atitiks reikiama, bus vykdomas kodas.
switch($salis) {
case ca :
case cr :
case us :
echo (Šiaures Amerika);
break;
case de :
case uk :
echo (Europa);
break;
}
Jei kintamojo $salis reikšme yra ca, cr arba us, tai i ekrana išvedama Šiaures
Amerika, jeigu de arba uk,
išvedama Europa.
13. Sesijos
Šis straipsnis yra parašytas remiantis tik teorinemis žiniomis apie sesijas,
neturint jokios patirties. Taigi
nepykite, jei kai kas bus netikslu ar klaidinga. Busiu dekingas visiems
išmanatiems sesijas už pastabas.
Na, o dabar prie reikalo. Su PHP4 atsirado nauja galimybe - integruotas sesiju
valdymas, kas leidžia saugoti
kintamuosius sesijos "objekte" viso apsilankymo metu.
Sesija - tai procesas, prasidedantis, kai lankytojas ateina i tinklapi, ir
pasibaigiantis, kai tinklapis paliekamas
(arba koks nors puslapis nutraukia ja). Dažniausiai cookie 's yra "pririšamas"
prie naršykles, o serveryje
išskiriama vieta saugoti sesijos kintamiesiems. PHP4 naudoja failus, taciau
teoriškai galima naudoti ir
duomenu bazes ir atmintine, sesijos kintamiesiems saugoti.
Visi puslapiai naudojantys sesijas turi iškviesti funkcija session_start(), kuri
pasako PHP varikliui, kad reikia
pakrauti sesijos informacija i atminti.
Sesijos kintamieji
Sesijos kintamieji - tai globaliniai kintamieji, kurie saugo kintamuju reikšmes
per visus tinklapius,
naudojancius sesijas. Šie kintamieji užregistruojami, naudojant funkcija
session_register("kintamasis"). Nuo
šiol visuose puslapiuose, kuriuose yra sesijos (su session_start()), bus galima
naudoti kintamaji $kintamasis
su ta reikšme, kuri buvo priskirta jam prieš užregistravima. Pvz.:
<?
session_start();
$kintamasis="Kintamojo reikšme";
session_register("kintamasis");
?>
Kaip matome iš pavyzdžio, registruojant sesijos kintamaji, jo vardas yra
nurodomas be $ ženklo. Dabar mes
panaudosime $kintamasis kitame puslapyje:
<?
session_start();
echo "Užregistruoto kintamojo reikšme $kintamasis";
?>
Kai kintamasis tampa nebereikalingas, ji galima sunaikinti su funkcija
session_unregister("kintamasis"). Taip
atlaisvinama dalis atminties, kuri susieta su kintamuoju.
Sesijos pabaiga
Sesijos pabaiga nera automatizuota. Serveriui sunku numanyti, kada vartotojas
užbaigia sesija. Yra keletas
komandu padesianciu pabaigti sesija:
1. Funkcija session_destroy(). Ja iškvietus sesija baigiama.
2. Jei sesijos ID yra saugomi cookie' iuose, galima pakeisti ju gyvenimo laika,
taip itakojant sesijos veikimo
laika.
3. Galima koreguoti php.ini faila. gc_maxlifetime reikšme nurodo, kiek laiko po
paskutinio naudojimosi sesijos
duomenimis jie yra ištrinami. Toks šiukšliu išvalymas reikalingas todel, kad
serveris nežino ar cookie' s vis
dar yra kliento puseje. Jeigu norima ištrinti senus sesijos duomenis, kai yra
gaunami nauji, gc_probability
savybei priskiriama reikšme nuo 1 iki 100. Jei reikšme 100, tai seni duomenys
pakeiciami naujais po
kiekvienos naujos užklausos. Jei reikšme 1 (pagal nutylejima), senu sesiju
duomenys bus ištrinami tik viena
karta per 100 užklausu.
Jeigu sesijos ID saugoti, vietoj cookie'u naudojami GET arba POST užklausos,
reiketu atkreipti ypatinga
demesi i šiukšliu išvalyma, nes lankytojas gali pasižymeti puslapi su senu
sesijos ID, ir jei nebus išvalyti seni
sesijos duomenys, lankytojas tes sena sesija, kas gali buti nenaudinga jums.
Sesiju ID
Sesiju ID gali buti saugomi trimis budais:
1. Cookie' iais (pagal nutylejima)
2. Per GET/POST metodus
3. Automatiškai arba rankiniu budu perrašinejant URL.
Kai sesijos ID sagomi cookie'iuose, jums nereikia rupintis niekuo, nei
konfiguracija, nei papildomo kodo
rašymu. Kitas dažnai naudojamas budas yra rašyti ID GET užklausoje. Tada URL
atrodys maždaug taip:
skriptas.php?=. URL galima perrašineti naudojant globaline konstanta SID:
<?
printf("<a href=skriptas.php?%s>"Nuorodoa</a>, SID);
?>
arba funkcija session_id():
<?
$id=session_id();
print "<a href=skriptas.php?$id>Nuoroda</a>";
?>
Sesiju teorijos tiek. php.lt yra straipsnis apie prisijungima su sesijomis.
Straipsniai apie sesijas:
http://www.phpdeveloper.org/view_tut.php?id=31
http://www.zend.com/zend/tut/session.php
http://www.phpbuilder.com/columns/mattias20000105.php3?print_mode=1
http://www.phpbuilder.com/columns/mattias20000312.php3?print_mode=1
14. Objektinis programavimas
Dabar siulau susipažinti su pagrindiniais objectinio programavimo terminais:
Klase - tai rinkinys funkciju ir kintamuju, bendradarbiaujanciu tarpusavyje.
Savybes - tai klaseje naudojami kintamieji.
Metodai - tai klaseje naudojamos funkcijos.
Konstruktorius - tai funkcija ivykdoma sukuriant klase (sukuriant objekta).
Iš šiu painiu apibrežimu sunku ka nors suprasti. Bet manau, jog perskaite ši
straipsni susidarysite bent
minimalu vaizda apie objektini programavima (OOP - Object Oriented Programming).
Taigi, pradekime nuo sintakses. Klases aprašomos naudojant operatoriu Class.
Klasiu kodas rašomas tarp
riestiniu skliaustu, lygiai kaip ir aprašant paprastas funkcijas:
<?
class klase{
// cia aprašomos objekto savybes
var $savybe1;
var $savybe2;
// cia aprašomi metodai
function metodas($kint)
{
// kodas
}}
?>
Kaip matome, savybes yra aprašomos naudojant operatoriu var. Dabar pateiksiu
pavyzdi iš realaus
gyvenimo, kuri butu galima susieti su OOP. Automobilis. Tai bus musu objektas.
Kaip žinome jis turi keleta
savybiu: spalva, forma, dydi, galia ir t.t. Tai bus musu objekto savybes. Taip
pat jis gali atlikti keleta
veiksmu: pajudeti iš vietos, pasukti, sustoti, važiuoti. Visa tai bus objekto
metodai. Dabar visa tai
aprašykime PHP kodu:
<?
class automobilis
{
// automobilio savybes
var $pavadinimas;
var $spalva;
var $forma;
var $dydis;
var $galia;
function pajudeti()
{
// kodas
}
function sustoti()
{
// kodas
}
function vaziuoti($greitis)
{
//kodas
}
function pasukti($kampas)
{
// kodas
}}
?>
Kaip matome, viskas pakankamai paprasta. Taigi dabar panaudosime ši objekta.
Sukurkime keleta
automobiliu:
<?
// sukuriame mano automobili
$mano=new automobilis;
$mano->pavadinimas="BMW";
$mano->spalva="Juoda";
$mano->galia="200 AG";
// sukuriame jos automobili
$jos=new automobilis;
$jos->pavadinimas="Ferrari";
$jos->spalva="Raudona";
$jos->galia="300 AG";
// na, o dabar mamo automobilis turetu pajudeti iš vietos
$mano->pajudeti();
// o dabar padidinti greiti iki 150 km/h
$mano->vaziuoti(150);
// o, štai atlekia jos automobilis
$jos->vaziuoti(180);
// o ne, keliu policija.........
$mano->sustoti();
?>
Naujas objektas sukuriamas panaudojant operatoriu new. Kintamajam priskiriama
"object" tipo reikšme, taip
paverciant ji objektu. Panaudojant -> (priešingai ne JavaScript ir kt.) mes
galime pasiekti visas objekto
savybes ir metodus. Reikšmiu priskyrimas objekto savybems yra identiškas
reikšmiu priskyrimui
kintamiesiems.
Naudojant OOP dažnai reikia keisti objekto savybiu reikšmes pacios klases
viduje. Tam yra naudojamas
išskirtas kintamasis $this, nurodantis, jog savybe priklauso esamai klasei.
<?
class automobilis
{
var $pavadinimas;
var $spalva;
// ............. kitos savybes ............
function perdazyti($spalva)
{$
this->spalva=$spalva;
}}
$auto=new automobilis;
$auto->spalva="Raudona";
$auto->perdazyti("Juoda");
?>
Panaudojant $this galima ne tik naudoti objekto "vietines" savybes. Taip pat
galima vykdyti ir metodus.
Na, o dabar pavyzdys iš praktinio klasiu pritaikymo: sukursime klase, kuri
sukurs HTML lentele, su nurodytu
skaiciumi eiluciu ir stulpeliu.
<?
class lentele
{
var $eil;
var $stulp;
// nurodyti eiluciu ir stulpeiu skaiciu
function nustatyti($eil, $stulp)
{
$this->eil=$eil;
$this->stulp=$stulp;
}
// sukurti lentele
function kurti_lentele()
{
echo "<table border=1>";
for ($x=1; $x<=$this->eil;$x++)
{
echo "<tr>";
for ($y=1; $y<=$this->stulp;$y++)
{
echo "$x, $y";
}
echo "</tr>";
}
echo "</table>";
}
}
?>
Šioje klaseje yra du metodai: nustatyti(), kuris nurodo, kiek eiluciu ir
stulpeliu tures lentele, ir
kurti_lentele(), kuris atvaizduoja lentele pagal nurodytus duomenis. Štai
panaudojimas:
<?
$obj=new lentele;
$obj->nustatyti(2,3);
$obj->kurti_lentele();
?>
OOP taip pat galima aprašytiyti funkcija, kuri bus vykdoma sukuriant objekta.
Tokia funkcija vadinama
konstruktoriumi ir turi tureti toki pat pavadinima, kaip ir klase.
Pavyzdžiui, papildysime lenteles klase funkcija, kuri priskirs reikšmes
kintamiesiems pagal nutylejima.
<?
class lentele
{
var $eil;
var $stulp;
// dabar reikia konstruktoriaus
function lentele()
{$
this->eil=5;
$this->stulp=3;
}}
//kitos funkcijos
?>
O dabar galime kurti lentele, nenurodinedami parametru:
<?
$lent=new lentele;
$lent->kurti_lentele();
?>
Ivykde ši koda gausime 5x3 lentele.
Na, ir galiausiai papasakosiu apie viena iš svarbiausiu OOP galimybiu -
pleciamuma ir paveldimuma. Tai yra
labai paprasta: paprasciausiai sukuriame klase, kuri išplecia jau esama ir
paveldi jos metodus, savybes.
Išplesti jau esamai klasei yra naudojamas operatorius "extends". Taigi dabar
išplesime lenteles klase:
<?
class lentele
{
var $eil;
var $stulp;
var $krastine;
// nurodyti eiluciu ir stulpeiu skaiciu
function nustatyti($eil, $stulp)
{$
this->eil=$eil;
$this->stulp=$stulp;
}
// sukurti lentele
function kurti_lentele()
{
echo "<table border=$krastine>";
for ($x=1; $x<=$this->eil;$x++)
{
echo "<tr>";
for ($y=1; $y<=$this->stulp;$y++)
{
echo "$x, $y";
}
echo "</tr>";
}
echo "</table>";
}
}
class geresne_lentele extends lentele
{
function nurodyti_krastine($storis)
{$
this->krastine=$storis;
}}
?>
Tai tiek apie OOP. Kaip matote tai nera itin sudetinga, taciau reikia nuolat
tobulintis, praktikuotis, dirbti....
15. Tips and Tricks
Cia rasite patarimu, skriptu ir t.t.
15.1 parent::
Šitas tik ant senu php versiju rodos pradedant 4.0.4 arba net 4.0.5. kai turi
kažkokia klasiu hierarchija ir iš
paveldetos klases nori iššaukti tevini metoda, teoriškai turetum rašyti
parent::metodas();, bet, deja, jei
tevine klase yra ne tam paciam kataloge, gausi klaida, kad neimanoma rasti
tevines klases, todel reikia
kviesti naudojantis konkretu tevines klases varda: tevineKlase::metodas();.
15.2 Pranešimai apie klaidas
apie klaidas tai turiu tik viena, bet super patarima: visada užsidek
error_reporting (E_ALL). iš pradžiu bus
bjauru, nes rašant koda belekaip, php mes dafiga klaidu, bet reikia tik iprasti
atitinkamai programuoti.
tipiniai pataisymai:
· negalima naudoti kintamojo, prieš tai jo neapibrežus. todel visiems
ateinantiems iš formos
kintamiesiems reikia priskirti default reikšmes, nes jei vartotojas nieko
neivede, tai kintamasis nebus
net užsetintas. if (empty($var)) $var = '';
· $masyvas[indeksas] -> $masyvas['indeksas'], nors pirmas variantas ir veikia,
bet php pirma ieško
konstantos indeksas, nerades praneša klaida, ir vercia indeksa i string.
· isset($var) - patikrinti ar toks kintamasis išvis egzistuoja.
· @funkcija(), jei neišeina išvengti klaidu pranešimu vykdant funkcija,
operatorius @ panaikina juos.
tik nereikia persistengi, nes gali pakliuti i tokia padeti, kai tavo skriptas
sustoja neišmetes jokio
pranešimo.
· if ($kazkas) -> if (!empty($kazkas)), funkcija empty() negražina klaidos, jei
kintamasis
neegzistuoja.
· if (!$kazkas) -> if (empty($kazkas))
· for($i; $row = $list[$i]; $i++) -> for($i; isset($list[$i]); $i++) { $row =
$list[$i]; }, bandant
ivykdtyti salyga $row = $list[$i] po paskutinio elemento, gausit pranešima, kad
toks indeksas
neegzistuoja, todel priskyrima reikia vykdyti ciklo viduje, o salygoje tik
tikrinti ar egzistuoja toks
indeksas.
15.3 Search Engine Friendly PHP pages
Ivadas
Kai rašote skriptus svarbus dalykas yra galimybe perduoti kintamuosius iš vieno
skripto i kita. Vienas iš
metodu kaip tai padaryti - GET metodas. Butent apie ji cia ir papasakosiu. Kai
kurios paieškos sistemos
megsta neindeksuoti puslapiu kurie yra su GET metodu parametrais. Jei jus
neisitikine kaip tiksliai atrodo
GET metodu perduodami kintamieji, štai jums pavyzdys:
http://beta.php.lt/skriptas.php?page=news&id=2
Cia skriptui (skriptas.php) yra perduodami du kintamieji: $page bei $id. Juos
automatiškai turesite savo
skripte: $page == 'news' && $id == 2 .
Alternatyva iprastam GET metodui
Tai kaip gi galima apeiti štai roki url'a ? Ir kaip tada mes perduosim
parametrus kitam skriptui ? Štai jums
pavizdys kaip atrodo linkas kuri paieškos sistema jau supras kaip normalu:
iprastu GET metodu:
http://beta.php.lt/skriptas.php?page=news&id=2
musu variantai:
http://beta.php.lt/skriptas.php/page/news/id/2
http://beta.php.lt/skriptas.php/page.news/id.2
http://beta.php.lt/skriptas.php/page-news;id-2
arba
http://beta.php.lt/skriptas/page,news;id,2 (beta.php.lt variantas)
Cia jau kaip sugalvosite. Dažniausiai visi naudoja pati pirmaji varianta, bet
galima naudoti koki tik
sugalvosite.
Kodel vienas variantas liko be .php išpletimo? Tai imanoma padaryti Apache web
serveryje, kai ant
direktorijos Options parametruose yra nustatyta MultiViews arba Options All. (
apache httpd.conf
http://httpd.apache.org/docs/content-negotiation.html ). Tada jei serveris
neranda skriptas direktorijos,
bando ieškoti failo skriptas.* Musu atveju jis randa skriptas.php
Kaipgi gauti visus parametrus po skriptas.php? Galima pasinaudoti štai tokiais
PHP kintamaisiai:
$PATH_INFO, $REQUEST_URI, $SCRIPT_NAME. Pažiurekime kaipgi veikia jie ir kaip
mes visa tai realizuosime:
<?php
echo $PATH_INFO."<br>";
echo $REQUEST_URI."<br>";
echo $SCRIPT_NAME;
?>
Ši skripta savo web serveryje pavadiname url.php ir žiurime rezultatus. Ivedame
paprasciausia varianta:
http://localhost/url.php/pirmas/pirmo_reiksme/antras/antro_reiksme (kurie bando
ant savo darbiniu
kompiuteriu galite pasitestuoti ir MultiViews tada jus galite kreiptis i skripta
http://localhost/url/pirmas/pirmo_reiksme/antras/antro_reiksme) Rezultate
browseryje matysime kad visi
kintamieji mums gražina tai ko mums ir reikia. Patogesnis variantas yra naudoti
$PATH_INFO, kadangi prieš
tvarkantis su kintamaisiai nereikes iš gauto url'o striptinti(pašalinti) skripto
vardo, musu atveju -> url.php
Dabar reikia padaryti taip kad mes galetume naudotis ir paciais kintamaisiai?
Tai reiškia kad musu skriptuose
atsirastu kintamieji $pirmas ir $antras ir ju reikšmes butu analogiškos: $pirmas
== 'pirmo_reiksme' &&
$antras == 'antro_reiksme';
Tam galime padaryti štai tokia funkcija:
<?php
function decode_url() {
global $PATH_INFO;
// Jei PATH_INFO - yra. Jei yra uzhsetinti parametrai
if(isset($PATH_INFO)) {
// Skaidom URL'a musu atveju pagal '/'
$duomenys = explode('/', $PATH_INFO);
// Skaichiujam kiek paramtru ir ju reikshmiu atejo ish url'o
$num_param = count($duomenys);
if($num_param % 2 == 0) {
$duomenys[] = '';
$num_param++;
}
// Padarom kad atsirastu kintamieji $pirmas bei $antras bei ju reiksmes
for( $i = 1; $i < $num_param; $i += 2) {
$GLOBALS[$duomenys[$i]] = $duomenys[$i+1];
}
}
}
?>
Štai šia funkcija idedam i koki nors header faila, bei includiname kiekviename
skripte. Iš kart po jos
decodinam url'a paraše: decode_url();
Štai variantas kai turime tik viena skirybos ženkla '/', o kaip padaryti su
keliais? Pavyzdžiui
url.php/pirmas,pirmo_reiksme;antras,antro_reiksme ? Šiuo atveju $PATH_INFO ==
'/pirmas,pirmo_reiksme;antras,antro_reiksme';
Analogiškai darome funkcija:
<?
function decode_url()
{
// darom kad PATH_INFO prieinamas butu ir funkcijoje
global $PATH_INFO;
$duomenys = substr ($PATH_INFO , 1);
// skaidom url'a pagal pirma skirybos zhenkla ';'
$duomenys = explode(";",$duomenys);
// jei duomenu yra vikdysim toliau
if (isset($duomenys))
{
// zhiurim kiek yr tu variablu
$d_size = sizeof($duomenys);
for ($x=0;$x < $d_size; $x++)
{
// kiekviena gabaliuka skaidom pagal ','
$vars = explode(",",$duomenys[$x]);
if (isset($vars)&&sizeof($vars)==2)
{
// jei tokio variablo skripte dar nera, mes ji sukuriame
isset($GLOBALS[$vars[0]])?true:$GLOBALS[$vars[0]] = $vars[1];
}
}
}
}
decode_url();
// Shtai ir viskas :)
?>
Manau dabar supratote kaip veikia štai šis url rewraitingo budas.
Apache alternatyva
Apache turi taip pat gera moduli: mod_rewrite. Panšu url rezultata galime gauti
ir pasinaudojus apach'o
mod_rewrite moduliu. Štai jums mažas pavizdys:
.htaccess'e
RewriteEngine On
RewriteRule ^archyvas/([0-9]+)/([0-9]+)/([0-9])+ archyvas.php?data=$1-$2-$3
RewriteRule ^archivas$ index.php
Dabar jei kreipsimes i serveri štai tokiu url':
http://beta.php.lt/archyvas/2002/02/15 Servas perrašo url'a ir
kreipiasi štai taip: http://beta.php.lt/archyvas.php?data=2002-02-15
Idomus variantas? Tikriausiai pamate toki adresa patiketumete kad serveryje yra
kiekvienos dienos atskira
direktorija :)
RewriteRule ^archivas$ index.php
Ši eilute redirektina vartotoja i index.php jei url'e nenurodyta pilna data.
Jei norite naudotis rewrite engin'u jums httpd.conf'e atkomentuoti štai šia
eilute:
LoadModule rewrite_module libexec/mod_rewrite.so
// (win konfiguracijoje ji atrodo šiek tiek kitaip - skiriasi keliai)
O ar IIS varototojai taip gali? :) Deja ne.
p.s. pamastymui:
http://www.delfi.lt/news/daily/lithuania/article.php?id=716982
Kaip manote delfi savo serveryje turi daug daug daug direktoriju kiekvienai
naujienu kategorijai ir
subkategorijai?
Informacijos šaltiniai ir copyraitai
Kaip jau minejau, dauguma informacijos paimta iš mistinio php_lt.zip, kurio net
autoriaus nežinau. Jei jis
atsirastu, tepraneša apie tai man.
1 skyriaus informacija imta iš php_lt.zip bei iš Nikolajaus Krauklio straipsnio
betoje.
2,3,4 skyriu informacija imta iš php_lt.zip
5 skyriaus informacija imta iš php_lt.zip bei iš Nikolajaus Krauklio straipsnio
betoje.
6,7 skyriu informacija imta iš php_lt.zip bei šiek tiek nagu prikišta ir iš mano
puses.
8 skyriaus informacija imta iš php_lt.zip bei iš Žygimanto Beržiuno straipsnio
betoje.
9,10 skyriu informacija imta iš php_lt.zip
11,12,13,14 skyriu informacija imta iš Juliaus Praneviciaus straipsniu betoje.
15 skyriaus informacija imta iš betos. Autoriai Juozas Šalna bei Nikolajus
Krauklys.
Visi emailai:
Nikolajus Krauklys - webmaster@php.lt
Juozas Šalna - salna@ktl.mii.lt
Julius Pranevicius - slamstas@email.lt
Žygimantas Beržiunas -
webmaster@namukas.lt
Aš - scooox@delfi.lt
Geriausi PHP resursai:
http://beta.php.lt
http://php.tinklapis.lt
http://php.dar.lt
Skriptai
http://www.hotscripts.com
Ta proga noreciau pareklamuoti ir
www.fenix.mes.lt.
Apie ten visoki gramatini šlamšta praneškite man.