| Sisällysluettelo |
|
Erot eri tavoilla luotujen merkkijonojen käyttäytymisessä ilmenevät merkkijonojen parseroinissa. Katso myös erikoissymbolit merkkijonoissa.
Yksittäiset lainausmerkit - ’ ’
Yksinkertaisin tapa luoda merkkijonoja on käyttää yksittäisiä lainausmerkkejä ’ ’. Tällöin kaikkia lainausmerkkien välissä olevia merkkejä kohdellaan tavallallisina merkkijonon osina, eikä esim. muuttujilla ja erikoismerkeillä ole vaikutusta. Merkkijono voi kuitenkin sisältää valmiiksi aseteltuja rivinvaihtoja kuten seuraavassa esimerkissä.
echo 'tämä on merkkijono'; = tämä on merkkijono
Kaksinkertaiset lainausmerkit - ” ”
Kaksinkertaisilla lainausmerkeilla ” ” rajattu merkkijono toimii muuten samoin kuin yksittäisillä lainausmerkeillä rajattu, mutta sen sen sisällä esiintyvät muuttujat ja tietyt erikoissymbolit käsitellään. Kts. merkkijonojen parserointi.
$muut = 'muuttujat'; echo ”Myös $muut otetaan mukaan”; = Myös muuttujat otetaan mukaan
"Heredoc"-syntaksi.
Niinkutsutta ”heredoc” syntaksi on PHP 4:ssä esitelty tapa luoda merkkijonoja.
Syntaksi koostuu aloitussymboleista, vapaavalintaisesta tunnisteesta, merkkijonon sisällön muodostavasta tekstistä ja uudelleen esiintyvästä tunnisteesta, joka lopettaa merkkijonon tulematta kuitenkaan yhdistetyksi siihen. Merkkijonon aloittaa kolme pienempi kuin-merkkiä <<< ja heti niiden perään annettu tunniste. Tunnisteen täytyy noudattaa PHP:n normaaleja muuttujannimeämissääntöjä, eli se saa koostua ainoastaan kirjaimista, numeroista ja alaviivoista ja se ei saa alkaa numerolla.
Merkkijonon lopettavan tunnisteen täytyy esiintyä erillisellä rivillä, joka ei saa sisältää muotoiluja, esim sisennyksiä tai välilyöntejä. Rivi ei saa myöskään sisältää muita ylimääräisiä merkkejä, kuin tunnistetta suoraan seuraavan puolipisteen.
$mjono = <<<LOP
Tämä on
esimerkki
merkkijono
LOP;
echo $mjono;
= Tämä on
esimerkki
merkkijono
”Heredoc” syntaksi soveltuu eritoten pitkien, ennaltamuotoiltujen merkkijonojen luomiseen. Syntaksilla luodut merkkijonot käyttäytyvät samalla tavalla, kuin kaksinkertaisilla lainausmerkeillä rajatut, eli niiden sisältämät muuttujat ja erikoissymbolit tunnistetaan ja käsitellään. Ainoa poikkeus on, että tekstialueella esiintyviä lainausmerkkejä ei tarvitse edeltää \ symbolilla.
$muut =’muuttujat’;
$mjono = <<<LOP
Myös
$muut
käsitellään
LOP;
echo $mjono;
= Myös
muuttujat
käsitellään.
Erikoissymbolit merkkijonoissa.
Merkkijonot voivat sisältää symboleja tai merkkiyhdistelmiä, joilla on erikoismerkitys PHP:n syntaksissa. PHP käyttää kenoviivaa ’\’ symbolien erikoisroolien osoittamiseen tai kumoamiseen.
Yksinkertaisilla lainausmerkeillä rajattujen merkkijonojen sisältöä kohdellaan automaattisesti tavallisena tekstinä. Kaksoislainausmerkeillä tai heredoc-syntaksilla luodut merkkijonot taas voivat sisältää muuttujaviittausten lisäksi tiettyjä merkkiyhdistelmiä, jotka muunnetaan parserointivaiheessa erikoissymboleiksi. Seuraavilla kenoviivan ’\’ edeltämillä merkeillä voidaan merkkijonoihin sisällyttää muotoiluja.
\n - tyhjä rivi
\r - rivinvaihto
\t - sisennys (vastaa tabulaattorin painallusta).
---
echo "yksi \r kaksi";
= yksi
kaksi
Kenoviivaa voidaan käyttää myös päinvastaisesti estämään jonkin symbolin käsittely. Näin toimitaan, jos merkkijon tavallisena osana tulisi esiintyä symboli, jolla on PHP:n syntaksissa erikoismerkitys.
\\ - Tekstin osana esiintyvä kenoviiva \. \$ - Tekstin osana esiintyvä dollarimerkki (muuttujaviittaukseen).
Huomaa, että jos merkkijonon luomiseen käytetty lainausmerkki esiintyy myös merkkijonon sisällä, sen täytyy olla kenoviivan \ edeltämä, ettei sitä tulkittaisi lopetusmerkiksi. Tämä pätee myös yksinkertaisilla lainausmerkeillä luotuihin merkkijonoihin.
echo ’lainaus täytyy merkitä \’näin\’’; = lainaus täytyy merkitä ’näin’
Merkkijonojen parserointi tarkoittaa merkkijonon sisältämien muuttujien ja erikoissymbolien käsittelyä. Tuloksena merkkijonosta tunnistetut muuttujaviittaukset ja erikoissymbolit korvautuvat vastaavilla alijonoilla ja merkeillä. PHP suorittaa parseroinnin automaattisesti aina, kun merkkijonoon viitataan.
Yksittäisten lainausmerkkien ympäröimän merkkijonon mahdollisesti sisältämiä muuttujia ei käsitellä erikseen, vaan niitä kohdellaan automaattisesti tavallisena tekstinä. Kaksoislainausmerkeillä ja heredoc-syntaksilla luodut merkkijonot parseroidaan identtisesti.
PHP käyttää kahta erilaista syntaksia muuttujien sisällyttämisessä merkkijonoihin: yksinkertaista (simple) ja PHP 4:ssä esiteltyä monimutkaista (complex) syntaksia.
Yksinkertainen syntaksi
Yksinkertainen syntaksi, jota ylläolevat esimerkit käyttävät, on useimmin käytetty tapa liittää muuttujia merkijonoihin.
Yksinkertaisessa syntaksissa muuttujien nimet esiintyvät merkkijonossa dollarimerkin $ edeltäminä. Symbolin $ kohdatessaan parseri koostaa sitä seuraavista merkeistä mahdollisimman pitkän muuttujan nimeksi kelpaavan merkkijonon ja koettaa tunnistaa sen. Tästä syystä muuttujaviittauksen täytyy yksinkertaista syntaksia käytettäessä rajoittua joko välilyöntiin tai muuttujan nimeen kelpaamattomaan merkkiin.
$nimi = ’Maijan’; echo ”$nimi kissa”; = Maijan kissa. (Toimii, koska muuttujan nimeä seuraa välilyönti.) --- $nimi = 'Maija'; echo "$nimi's cat"; = Maija’s cat. (Toimii, koska ‘ ei ole kelvollinen merkki muuttujan nimessä.) --- $nimi = ”Maija”; echo ”$nimin kissa.”; = virhe, koska myös kirjain n tulkitaan muuttujan nimen osaksi. muuttujan nimen rajaamiseksi täytyy käyttää monimutkaista syntaksia.
Yksinkertainen syntaksi soveltuu ainoastaan yksittäisten muuttujien tai objektitietueiden sekä yksiulotteisten taulukkojen käsittelyyn. Jos viittaus on esim. moniosainen tai kohdistuu moniulotteiseen taulukkoon, on syytä käyttää monimutkaista syntaksia.
echo "arvo = $taul[$i][$j]"; = Virhe, koska vain ensimmäinen sulkupari tulkitaan osaksi viittausta.
Monimutkainen syntaksi.
Monimutkainen syntaksi, joka on esitelty PHP:n versiossa 4, mahdollistaa kaikkien PHP:n hyväksymien muuttujaviittausten käytön merkkijonojen sisällä. Monimutkaisessa syntaksissa muuttujaviittaus tai viittaussarja suljetaan sulkujen { } sisään. Tällöin sulkujen väliin jäävä osa käsitellään kokonaisuudessaan ja lopputulos liitetään osaksi merkkijonoa.
Viittaukset käyttäytyvät täsmälleen samalla tavalla kuin merkkijonon ulkopuolella esiintyessään. Muuttujaviittaus alkaa edelleen dollarimerkillä $ merkillä, jonka täytyy välittömästi seurata avaavaa sulkumerkkiä. Myös loppusulku täytyy sijoittaa heti viittauksen viimeisen merkin jälkeen.
echo "arvo 4,3 on: {$taul[4][3]}";
---
echo "Tämän objektin nimi on: {$objekti->nimi}";
---
echo "Muuttujan arvo on: { $arvo}";
= virhe, koska sulun ja dollarimerkin välissä on välilyönti.
Monimutkaista syntaksia voidaan käyttää myös, jos merkkijonon keskellä esiintyvän yksittäisen muuttujan nimi täytyy erottaa tarkasti ympäröivistä merkeistä.
$nimi = "Maija";
echo "{$nimi}n kissa.";
= Maijan kissa
Merkkijono-operaattorit
Merkkijonojen välillä voidaan käyttää kahta operaattoria, liitosoperaattoria ’. ’ (piste) ja liittävää sijoitusoperaattoria ’.= ’ (piste ja yhtäsuuruusmerkki).
Liitosoperaattori ’.’ palauttaa vasemman ja oikeanpuoleisten argumenttien yhdistelmän.
$a = "Yksi "; $b = $a . ", kaksi"; echo $b; = yksi , kaksi
Liittävä sijoitusoperaattori ’.= ’ liittää oikeanpuoleisen argumentin vasemmanpuoleisen perään.
$a = ”Yksi ”; $a .= ”, kaksi”; echo $a; = yksi, kaksi
Indeksoitu viittaaminen merkkijonoon
Merkkijonomuuttujan sisältämiin yksittäisiin merkkeihin voidaan viitata taulukkomaisesti indeksin avulla. Tällöin normaalin muuttujakutsun perään liitetään hakasulkumerkeillä { }ympäröity indeksinumero. Ensimmäisen merkin indeksiarvo on aina 0 ja viimeisen merkkijonon pituus -1. Indeksillä varustettua merkkijonomuuttujaa kohdellaan kuin merkkijonoa, jonka pituus on yksi.
$jono = 'abc';
$ens = $jono{0};
echo $ens;
= a
Huom. PHP 4:sta edeltävissä versioissa indeksointiin käytetään taulukkomaisesti hakasulkuja [ ].
PHP ei tue muuttujan tyypin pysyvää määrittelyä. Muuttujan kulloinenkin tyyppi riippuu siitä, minkä tyyppinen arvo sille on viimeksi annettu.
$muut = 10; ($muut on kokonaisluku) $muut = 10.10; ($muut muuttuu liukuluvuksi) $muut = "kymmenen"; ($muut muuttuu merkkijonoksi)
Lisäksi se, minkä tyyppisenä muuttuja kulloinkin käsitellään, riippuu siitä, missä yhteydessä sitä käytetään. Esim. aritmeettisten operaattorien kanssa esiintyvät muuttujat yritetään käsitellä numeerisina ja tulostusfunktiolle annettu muuttuja pyritään käsittelemään merkkijonona. Tästä syystä erillistä tyyppikonversiota ei usein tarvita. PHP sisältää kuitenkin funktioita, jolla muuttujan varsinainen tyyppi voidaan muuttaa halutuksi, sekä tyypittimiä, joilla automaattinen konversio voidaan tilannekohtaisesti kumota.
Seuraavassa käsitellään näitä tapoja muuttujan tyypin määrittelyyn, ja sitä, miten eri muuttujatyypit käyttäytyvät kun niitä muunnetaan merkkijonoiksi. Nämä säännöt pätevät sekä tyyppimuunnokseen, että tilannekohtaiseen tulkintaan.
Muiden tyyppien muuntaminen merkkijonoiksi
Muuttuja voidaan tyypittää merkkijonoksi lisäämällä tyypitin (typecast) (string) muuttujan nimen eteen. Tämä pätee vain siinä lausekkeessa, missä tyypitin esiintyy, eli esimerkin suorittamisen jälkeen muuttuja $luku on edelleen kokonaislukutyyppinen.$luku = 10; ($luku sisältää kokonaisluku-arvon.) $mjono = (string) $luku; ($mjonon arvoksi tulee merkkijono '10'.)
Jos muuttujan varsinainen tyyppi halutaan muuttaa pysyvästi, käytetään funktiota settype. Settype-kutsu on muotoa settype($muuttuja, "tyyppi"), jossa $muuttuja on muuttujan nimi dollarimerkin edeltämänä ja "tyyppi" kaksinkertaisilla suluilla ympäröity, PHP:n tuntema muuttujatyyppi. Huomaa, että tämäkin muunnos pätee vain niin kauan, kun muuttuja saa vain merkkijono-tyyppisiä arvoja.
$boo = true; settype($boo, "string"); ($boo on merkkijono-tyyppinen muuttuja, jolla on arvo '1'.)
Eri muuttujatyypit käyttäytyvät hieman eri tavalla, kun niitä yritetään muuntaa merkkijonoiksi.
Merkkijonojen muuntaminen numeroiksi
PHP yrittää automaattisesti muuttaa merkkijonon numeeriseksi arvoksi, jos sitä käytetään kuten numeerista muuttujaa, esim yhdessä numeroiden ja aritmeettisten operaattorien kanssa. Konversio voidaan myös pakottaa tyypittimellä (integer) tai settype-funktiolla.
Jos heti merkkijonon alussa esiintyy kelvollisen kokonais- tai liukuluvun muodostava alijono, tämän arvoa käytetään operaatiossa. Jos taas ensimmäisestä merkistä alkavaa kelvollista numeroa ei pystytä lukemaan, merkkijonolle annetaan arvo 0. Kelvollinen numeerinen jono saa sisältää numeroiden lisäksi pisteen ’.’, pilkun ’,’ ja/tai exponenttimerkin e/E normaalin syntaksin mukaisissa kohdissa.
Merkkijono voi sisältää muita merkkejä kelvollisen numerosyötteen jälkeen, mutta jos niitä esiintyy sellaista ennen, palautetaan arvo 0. Palautettava arvo on oletuksena kokonaisluku-tyyppinen, mutta jos numerossa esiintyy piste, pilkku, tai eksponenttimerkki, palautetaan liukuluku-tyyppinen arvo.
$luku = ”2 eli kaksi”;
$tulos = 1 + $luku;
echo $tulos;
= 3 {$luku saa kokonaisluku-arvon 2}
---
$luku = ”kaksi, eli 2”
$tulos = 1 + $luku;
echo $tulos;
= 1 {$luku saa kokonaisluku arvon 0}
---
$luku = ”2e2”;
$tulos = 2 + $luku;
echo $tulos;
= 202 {luku saa liukuluku-arvon 200}
Operaattoreiden lisäksi merkkijonojen käsittelyyn voidaan käyttää myös useita funktioita. Näistä kuuluu PHP:n ydinfunktioihin kuuluvat mm. tulostusfunktiot print, printf ja sprintf ja monenlaiset automaattista muotoilua suorittavat funktiot.
Funktiovalikoimaa voidaan lisäksi laajentaa funktiokirjastojen avulla. PHP tukee mm. PERL ja POSIX tyyppisiä säännöllisiä lausekkeita erillisten funktiokirjastojen kautta.
Yksityiskohtaista tietoa merkkijonojen käsittelyyn sopivista funktioista löytyy on-line PHP-manuaalista.
Kohdat:
PHP-kieli ja HTML-kieli eivät ole toisensa poissulkevia. Kumpaakin voidaan käyttää samassa dokumentissa täydentämään toista. Molempia ei ole kuitenkaan pakko käyttää, joten W3C-suositusten mukainen HTML-sivu voidaan tehdä myös pelkästään PHP-koodilla.
Kun selain pyytää PHP-koodia sisältävän sivun WWW-palvelimelta, se antaa sivun suoritettavaksi palvelimeen asennetulle PHP-tulkille. PHP-tulkki tutkii dokumentin rakenteen, suorittaa sivulla olevat PHP-kieliset komennot ja palauttaa WWW-palvelimelle työn tuloksena syntyneen staattisen dokumentin. WWW-palvelin palauttaa lopuksi dokumentin sitä pyytävälle selaimelle. PHP-kielellä täydennetyt sivut (kuten yleensä kaikki muutkin dynaamiset WWW-sivut) näkyvät siis selaimella kuten mitkä tahansa HTML-sivut.
PHP-tulkki ohittaa kaiken mikä on PHP lohkon ulkopuolella. PHP-skriptin
voi
upottaa mihin tahansa paikkaa HTML-koodin sekaan.
Esim. "Hei maailma" skriptin tekeminen
<?php
print "Hei maailma";
?>
PHP-tulkin muokkaama WWW-sivu näyttää seuraavalta:
<html><head><title>Hei maailma!</title></head>
<body>
Hei maailma!
</body></html>
Mukana ei enää ole minkäänlaista viittausta PHP-koodiin.
WWW-maailmassa HTML-lomakkeet ovat peruskeino kerätä tietoa
käyttäjältä
ja viedä tieto palvelimelle. PHP on kehitetty nimenomaan lomaketiedon
käsittelyyn.
HTML-lomake on Web-sivuilla oleva alue jonka avulla käyttäjä
voi esim. syöttää tietoa lähettääkseen ne Web-selaimen
avulla Web-palvelimelle ja sitä kautta sovellukselle. (esim. PHP, Perl
sovellukselle)
Lomakkeita voidaan käyttää tiettyihin tarkoituksin myös ilman palvelinpuolen
ohjelmia. Tällaisiin lomakkeisiin voidaan käyttää myös
asiakaspuolen ohjelmointia
(esim. JavaScript). Jos lomakkeilla halutaan tehdä jotain
toiminnallisuutta,
lähetetään lomakkeen data eteenpäin palvelimelle jossa esim. PHP skripti tekee
halutut toiminnot. PHP:n avulla voidaan HTML sivuille lisätä dynaamisuutta
ja vuorovaikutteisuutta käyttäjän ja palvelimen välillä.
Joissakin olosuhteissa saatta olla hyödyllistä sijoittaa lomakkeen
jäsentelykoodia samalle sivulle, jossa HTML-lomake on. Sellainen
yhdstelmä
voi olla hyödyllinen jos on esitettävä sama lomake käyttäjälle
useamman kerran.
- Form, Input, Textarea, Select, Option
HTML-kielessä on tarjolla lomake-elementti, jonka avulla voidaan
välittää tietoa palvelimessa käynnistettävälle
ohjelmalle:
<FORM miten ja minne>'Miten ja minne' yllä määrittelee parametrien välitystavan sekä käynnistettävän ohjelman. Lomake-elementin alku voisi olla:
lomakkeen kenttien määrittely
</FORM>
<FORM method="get" ACTION="HTTP://www.cs.joensuu.fi/cgi-bin/form.php">
Tällöin lomakkeen lähetyksen yhteydessä käynnistyisi palvelimella
www .cs.joensuu.fi
hakemistossa cgi-bin oleva form.php - niminen ohjelma. Parametrit tälle ohjelmalle välitettäisiin tarkoitukseen varatun ympäristömuuttujan kautta
(method=get).Parametrit voitaisiin välittää myös standardisyöttöjonon kautta (method=post). Standardisyöttö jonoon perustuvaa välitystapaa on käytettävä, jos väitettävän parametritiedon määrä on suuri. Lomakkeen lähetyksen yhteydessä parametrien arvot talletetaan ympäristö muuttujaan tai syöttöjonoon samassa muodossa, jossa ne esitettäisiin URL:iin liitettyinä.
Lomakkeen erottaa muun tyyppisestä HTML-dokumentista se, että lomake voi sisältää kenttiä. Vähimmillään lomakkeella on oltava lähetysnappi, jota painamalla kenttien arvot lähetetään parametreina kutsuttavalle ohjelmalle.
Lomakkeen kentät esitetään input-, textarea tai select-elementteinä.
<INPUT TYPE="tyyppi" NAME="nimi" VALUE="arvo">
Kenttätyyppejä ovat (attribuutti type):
PHP-skriptissä käsiteltävät tiedostot voidaan jakaa paikallisiin ja etätiedostoihin. Paikalliset tiedostot sijaitsevat koneella, jossa skripti suoritetaan. Etätiedostot puolestaan voivat sijaita millä tahansa internet/intranet-verkossa olevalla koneella.
Kun PHP:ssä avataan tiedosto, jota ei olemassa, se luodaan automaattisesti. Jotta tämä onnistuisi täytyy muut (others)-ryhmään kuuluvilla olla kirjoitus ja lukuoikeudet hakemistoon jonne tiedosto luodaan. Jos hakemistoon minne tiedosto luotaisiin ei ole kirjoitus oikeutta, tai kirjoitusoikeutta ei haluta antaa, täytyy tiedosto luoda valmiiksi ja antaa tiedostoon luku- ja kirjoitusoikeus.
esim. Tiedoston luominen ja oikeuksien antaminen
cs: ~/web-docs>touch tiedosto.jota.kaytetaan cs: ~/web-docs>chmod o+wr tiedosto.jota.kaytetaan cs: ~/web-docs>
Tiedoston avaus tapahtuu fopen-funktiolla ja sulkeminen fclose -funktiolla. Fopen-käsky luo tiedoston, jos skriptin oikeudet riittävät, muuten PHP-tulkki tulostaa virheilmoituksen riittämättömistä oikeuksista.
fopen:
$tiedoston_kahva=fopen("tiedoston_nimi", "kuinka_avataan");
$tiedoston_kahva=fopen("http://www.jokuosoite.fi/", "kuinka_avataan");
$tiedoston_kahva=fopen("ftp://tunnus:salasana@ftp.osoite.fi/", "kuinka_avataan");
fclose:
fclose($tiedoston_kahva);
| "r" | = | Tiedosto avataan lukemista varten. |
| "r+" | = | Tiedosto avataan lukemista ja kirjoittamista varten |
| "w" | = | Tiedosto avataan kirjoittamista varten. Tiedosto
luodaan/tyhjennetään, jos oikeudet riittävät. |
| "w+" | = | Tiedosto avataan lukemista ja kirjoittamista varten.
Tiedosto luodaan/tyhjennetään, jos oikeudet riittävät. |
| "a" | = | Tiedosto avataan lisäystä varten. Tiedostoa ei tyhjennetä ja
lisäys tiedoston loppuun. |
| "a+" | = | Tiedosto avataan lukemista ja lisäystä varten. Tiedostoa
ei tyhjennetä ja lisäys tiedoston loppuun. |
Esim. 1: Paikallisen tiedoston avaus ja sulkeminen.
<?php
# Avataan tiedosto tiedoston.nimi luettavaksi.
# tähän tiedostoon viitataan muuttujalla $f.
echo "Avataan tiedosto.<br>\n";
$f=fopen("tiedosto.nimi", "r");
if (!$f)
echo "Tiedostoa ei voitu avata.<br>\n";
else
{
echo "Tiedoston avaus onnistui. Suljetaan tiedosto.<br>\n";
fclose($f);
}
?>
<?php
# Avataa osoitteesta http://cs.joensuu.fi/ löytyvä
# tiedosto luettavaksi.
# tähän tiedostoon viitataan muuttujalla $f.
echo "Avataan etätiedosto<br>\n";
$f=fopen("http://cs.joensuu.fi/", "r");
if (!$f)
echo "Tiedostoa ei voitu avata.<br>\n";
else
{
echo "Tiedoston avaus onnistui.<br>\n";
echo "Suljetaan tiedosto.<br>\n";
fclose($f);
}
?>
Pelkällä tiedostojen avaamisella ja sulkemisella ei vielä saa aikaa mitään kiinnostavaa. Seuraavaksi tutustummekin tiedostojen lukuun ja kirjoitukseen.
Tiedoston sisältöä voidaa lukea fgets, file ja include -funktioilla. Tiedostoon voidaan kirjoittaa fputs -funktiolla. Include -funktio oikeastaan liittää parametrinaan saadun tiedoston sisällön sellaisenaan kohtaan, jossa include-funktiota kutsuttiin, joten usein sitä käytetään kuten C:n #include:a. Tiedostoon kirjoitetaan fputs-funktiolla.
fgets:
# Lukee tiedostoa seuraavaan rivinvaihtomerkkiin asti tai enintää 1024 tavua.
$rivi=fgets($tiedoston_kahva);
# Lukee tiedostoa seuraavaan rivinvaihtomerkkiin asti tai enintään n tavua.
$rivi=fgets($tiedoston_kahva, n);
file:
# Lukee tiedoston sisällön taulukkoon nimeltä rivit. $rivit[0] on ensimmäinen
# rivi, $rivit[1] toinen jne.
$rivit=file("tiedoston.nimi");
$rivit=file("http://www.jokuosoite.fi/");
include:
# Liittää tiedoston sisällön sellaisenaan kohtaan, jossa include -funktion
# kutsu tapahtui.
include("tiedoston.nimi");
include("http://www.jokuosoite.fi/");
fputs:
# Tallentaa muuttujassa $rivi olevan tiedon tiedostoon.
# Kuintenkin korkeintaan 1024 tavua.
fputs($tiedoston_kahva, $rivi);
# Tallentaa muuttujassa $data olevan tiedon tiedostoon.
# Korkeintaan n tavua.
fputs($tiedoston_kahva, $data, n);
Esim. 3: Include
<?php
# liitetään Rekursion etusivun sisältö skriptiin.
include("http://cs.joensuu.fi/~rekursio/");
?>
Esim. 4: File
<?php
# Luetaan tiedoston sisältö.
$rivit=file("tiedosto.nimi");
# Tulostetaan kolme ensimmäistä riviä.
echo "Rivi 1: $rivit[0]<br>";
echo "Rivi 2: $rivit[1]<br>";
echo "Rivi 3: $rivit[2]<br>";
?>
Esim. 5: Fgets ja fputs
# Avataan tiedosto lukua ja kirjoitusta varten.
$tiedosto=fopen("tiedosto.nimi", "r+");
echo "Tulostetaan tiedoston sisältö.<br>\n";
# feof($tiedoston_kahva) palauttaa EOF:n, kun
# päästään tiedoston loppuun.
$nro=1;
while (EOF!=feof($f))
{
# fgets($tiedoston_kahva) lukee tiedostosta
# yhden rivin.
$rivi=fgets($f);
echo "$nro. rivi: $rivi<br>";
}
# Tallennetaan $rivi-muuttujan uusi sisältö tiedoston loppuun.
echo "muttujan rivi sisältö on $rivi<br>Tallennetaan se tiedoston loppuun.<br>";
$rivi="Tämä teksti tulee tiedoston loppuun!\n";
fputs($f, $rivi);
echo "Suljetaan tiedosto<br>\n";
fclose($f);
Tässä osiossa keskitytään relaatiotietokantoihin ja SQL-kieleen, joista lukijan oletetaan tietävän perusteet. Jokainen tietokantataulu on järjestetty rivieihin ja sarakkeisiin ja niiden leikkauspiste määrittää haettavan ja tallennettavan tiedon. Jokaiselle sarakkeelle on määritelty tietty tietotyyppi, esimerkiksi INT kokonaisluvulle ja VARCHAR vaihtelevan pituiselle merkkijonolle tiettyyn ylärajaan asti. Sarakkeeseen voi tallentaa ainoastaan sille määrätyn tietotyypin tietoa.
Osion esimerkeissä käytetään alla olevan taulukon mukaista tietokannan taulua ja esimerkit esitetään ODBC- ja MySQL -funktioiden avulla.
| asiakas | |
| varchar(50) | as_nimi |
| varchar(11) | as_puhnro |
| varchar(25) | as_email |
Tietoja haetaan tietokannasta SELECT-, tallennetaan INSERT-, päivitetään UPDATE- ja poistetaan DELETE -lauseilla.
PHP:n avulla on mahdollista käyttää ainakin seuraavia tietokantoja:
Ennen kuin tietokantaa voi hyödyntää PHP:ssä, siihen täytyy luoda tietokantayhteys. Jokaiselle tietokannalle on olemassa PHP:hen sisäänrakennetut funktiot sen käsittelyä varten. Esimerkiksi MySQL-tietokantaan avataan yhteys mysql_connect() -funktiolla ja kaikkiin ODBC-rajapinnan alla oleviin tietokantoihin saadaan yhteys odbc_connect() -funktiolla. Yleisesti voidaan todeta että tarvittavan funktion nimi on muotoa <tietokannannimi>_connect().
mysql_connect() -funktio ei tarvitse yhtään parametriä, mutta se voi ottaa vastaan kolme (palvelimen nimi, käyttäjätunnus, salasana). Mikäli yksikin parametreistä jätetään antamatta, funktio olettaa että palvelimen nimi on "localhost" ja ettei käyttäjätunnusta tai salasanaa ole määritelty mysqluser -tietokantatauluun. Alla oleva esimerkki yrittää avata yhteyttä "mun_webbipalvelin" -nimisellä koneella sijaitsevaan mysql-palvelimeen käyttäjätunnuksella "kissa" ja salasanalla "ken_söi_kesävoin_eikä_barbie".
Mikäli yhteydenotto ei onnistunut, poistutaan skriptistä ja tulostetaan virheilmoitus.
<?php
// avataan yhteys tietokantaan
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
// tulostetaan virheilmoitus, jos avaus ei onnistunut.
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
?>
<?php
$yhteys = odbc_connect("tietokannan_nimi_odbc_rajapinnassa",
"käyttäjätunnus","salasana");
if (! $yhteys )
die( "*Jälleen kuolonkorahdus* ODBC -tietokantaa ei voinut avata!" );
?>
*_pconnect()-funktio ei sulje yhteyttä kun PHP-skriptin suoritus päättyy tai kun kutsut funktiota *_close(), vaan yhteys jää auki odottamaan seuraavaa *_pconnect()-kutsua.
Pysyvä yhteys nopeuttaa tiedonhakua tietokannasta, sillä sitä ei tarvitse luoda joka kerta alusta asti uudelleen. Kuitenkin www-palvelin katkaisee itse pysyvän yhteyden määrätyn ajan kuluttua tai kun yhteyttä on käytetty tietty määrä.
Lisätietoja yhteyden sulkemisesta Apachessa http://httpd.apache.org/docs/mod/core.html
Kun olemme saaneet yhteyden MySQL-tietokantapalvelimeen, täytyy sieltä valita oikea tietokanta mitä halutaan käsitellä. Tietokannan valitseminen tapahtuu mysql_select_db() -funktion avulla. Se tarvitsee parametrikseen tietokannan nimen tai vaihtoehtoisesti yhteyden tunnisteen. mysql_select_db() palauttaa totuusarvon TOSI jos tietokanta on olemassa, ja sitä on mahdollista käsitellä. Alla olevassa esimerkissä valitsemme tietokannan nimeltä "aivopesu" ja mikäli tietokantaa ei saada valittua, palautetaan virheilmoitus mysql_error() -funktion avulla.
mysql_error() palauttaa viimeisimmän mysql-funktion tekemän virheen. Mikäli käytät tätä funktiota, tarkista sen arvo ennen kuin kutsut toista mysql-funktiota.
<?php
$tietokanta = "aivopesu";
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
// tulostetaan virheilmoitus, jos avaus ei onnistunut.
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
mysql_select_db( $tietokanta )
or die ( "Nyt tuli noutaja, tietokantaa $tietokanta ei voinut valita".mysql_error() );
?>
ODBC-rajapinnan kautta avattava tietokantaa ei tarvitse erikseen enää valita, vaan voimme suoraan käsitellä sitä yhteyden avaamisen jälkeen.
Kuten avausfunktiotkin, yhteydensulkufunktiot ovat tietokantakohtaisia. MySQL-tietokantaan avatun yhteyden voi sulkea komennolla mysql_close($yhteyden_tunnus), jossa $yhteyden_tunnus on mysql_connect() -funktion palauttama yhteys.
<?php
$yhteys = mysql_connect();
// ohjelmalauseita...
mysql_close($yhteys);
?>
ODBC-yhteyden voi sulkea funktion odbc_close($yhteyden_tunnus) avulla.
<?php
$yhteys = odbc_connect("tietokantani","tieto","kanta");
// ohjelmalauseita...
odbc_close($yhteys);
?>
Lisätäksemme tiedon tietokantaan, tulee muodostaa ja suorittaa SQL-kysely. MySQL -tietokantaa käsitellessä voidaan käyttää mysql_query() -funktiota tähän tarkoitukseen. Funktio tarvitsee parametreikseen INSERT -lauseen ja vaihtoehtoisesti yhteyden tunnuksen. Jos tunnistetta ei anneta, kysely lähetetään sille tietokantapalvelimelle, johon yhteys on avattu viimeksi.
mysql_query() palauttaa totuusarvon TOSI (true), mikäli kysely ei sisällä virheitä ja tietokantaan on suoritusoikeus. Muussa tapauksessa paluuarvo on EPÄTOSI (false). INSERT -lauseen syntaksi on seuraava:
INSERT INTO [taulunnimi(sarake1, sarake2, ...)] VALUES (arvo1, arvo2,...)
<?php
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
mysql_select_db( "asiakaskanta" )
or die ( "Tietokantaa ei voinut valita".mysql_error() );
$lause ="INSERT INTO asiakas(as_nimi, as_puhnro, as_email)
VALUES ('Bond, James Bond', '555-BOND', 'james.bond@licence2kill.org')";
mysql_query($lause, $yhteys)
or die ( "asiakas -tauluun ei voinut lisätä tietoa." );
mysql_close($yhteys);
?>
ODBC-rajapintaa hyödynnettäessä tilanne on lähes sama, paitsi funktion nimi on odbc_exec():
<?php
$yhteys = odbc_connect("tietokannan_nimi_odbc_rajapinnassa",
"käyttäjätunnus","salasana");
if (! $yhteys )
die( "*Jälleen kuolonkorahdus* ODBC -tietokantaa ei voinut avata!" );
$lause ="INSERT INTO asiakas(as_nimi, as_puhnro, as_email)
VALUES ('Bond, James Bond', '555-BOND', 'james.bond@licence2kill.org')";
odbc_exec($yhteys, $lause) or
die( "Asiakas-tauluun ei voinut lisätä tietoa.!" );
odbc_close($yhteys);
?>
Rivin tietojen hakeminen tapahtuu käyttäen SELECT -lausetta. SELECT -lauseen palauttamien rivien määrä saadaan selville käyttämällä mysql_num_rows() -funktiota, kun kyseessä on MySQL -tietokanta ja odbc_num_rows() -funktiota kun kyseessä on ODBC-rajapinnan kautta kulkeva tietokantayhteys. mysql_num_rows() ottaa parametrikseen mysql_query() -funktion palauttaman arvon. Vastaavasti odbc_num_rows() ottaa vastaan odbc_exec() -funktion palauttaman arvon.
SELECT -lause suoritetaan vastaavalla tavalla kuin INSERT -lausekin, paitsi se (mahdollisesti) palauttaa rivejä. SELECT -lauseen syntaksi on
SELECT [sarake1, sarake2,...] FROM [taulu1, taulu2, ...] WHERE [hakuehdot]
<?php
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
mysql_select_db( "asiakaskanta" )
or die ( "Tietokantaa ei voinut valita".mysql_error() );
$lause ="SELECT * FROM asiakas";
$lauseen_tulos = mysql_query($lause, $yhteys);
$rivien_lkm = mysql_num_rows( $lauseen_tulos );
print "Asiakas -taulussa on tällä hetkellä $rivien_lkm riviä<p>";
print "<table border=1>\n";
while ( $rivi = mysql_fetch_row( $lauseen_tulos ) )
{
print "<tr>\n";
foreach ( $rivi as $kentta )
print "\t<td>$kentta</td>\n";
print "</tr>\n";
}
print "</table>\n";
mysql_close($yhteys);
?>
ODBC-rajapintaa hyödynnettäessä
<?php
$yhteys = odbc_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* ODBC -tietokantaa ei voinut avata!" );
$lause ="SELECT * FROM asiakas";
$lauseen_tulos = odbc_exec($lause, $yhteys)
$rivien_lkm = odbc_num_rows( $lauseen_tulos );
print "Asiakas -taulussa on tällä hetkellä $rivien_lkm riviä<p>";
print "<table border=1>\n";
while ( $rivi = odbc_fetch_row( $lauseen_tulos ) )
{
print "<tr>\n";
foreach ( $rivi as $kentta )
print "\t<td>$kentta</td>\n";
print "</tr>\n";
}
print "</table>\n";
mysql_close($yhteys);
?>
Tiedot päivitetään käyttämällä UPDATE -lausetta. Sen suoritus ei eroa muiden lauseiden suorituksesta millään tavalla, paitsi se ei palauta rivejä. UPDATE -lauseen syntaksi on
UPDATE [taulun_nimi] SET sarake1 = arvo1, sarake2 = arvo2, ...
<?php
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
mysql_select_db( "asiakaskanta" )
or die ( "Tietokantaa ei voinut valita".mysql_error() );
$lause ="UPDATE asiakas SET as_email = 'austin.powers@shag-a-delic.org.asm'";
$kyselyn_tulos = mysql_query($lause, $yhteys);
if ( ! $kyselyn_tulos )
die (" Asiakas -taulua ei voinut päivittää: ".mysql_error() );
print "<p>Päivitys onnistui: ".mysql_affected_rows() ." riviä päivitetty.";
mysql_close($yhteys);
?>
<?php
$yhteys = odbc_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* ODBC -tietokantaa ei voinut avata!" );
$lause ="UPDATE asiakas SET as_email = 'austin.powers@shag-a-delic.org.asm'";
$kyselyn_tulos = odbc_exec($lause, $yhteys)
if ( ! $kyselyn_tulos )
die (" Asiakas -taulua ei voinut päivittää: ".odbc_error() );
print "<p>Päivitys onnistui.";
mysql_close($yhteys);
?>
Tietokannasta poistetaan tietoa DELETE -lauseella. Sen syntaksi on:
DELETE [taulun_nimi] WHERE [ehto]
[taulun_nimi] on tietokantataulun nimi, esim. asiakas. [ehto] on nimi-arvo -parametri, jossa esimerkiksi taulun sarakkeen arvo on jotakin, kuten alla olevassa esimerkissä näkyy:
<?php
$yhteys = mysql_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* MySQL -tietokantaa ei voinut avata!" );
mysql_select_db( "asiakaskanta" )
or die ( "Tietokantaa ei voinut valita".mysql_error() );
// poistolause alkaa
$lause ="DELETE asiakas WHERE as_nimi = 'Bond, James Bond'";
$kyselyn_tulos = mysql_query($lause, $yhteys)
if ( ! $kyselyn_tulos )
die (" Tietuetta ei voinut poistaa: ".mysql_error() );
print "<p>Tietue poistettu.";
// poistolause loppuu
mysql_close($yhteys);
?>
<?php
$yhteys = odbc_connect("mun_webbipalvelin","kissa",
"ken_söi_kesävoin_eikä_barbie");
if (! $yhteys )
die( "*Kuolonkorahdus* ODBC -tietokantaa ei voinut avata!" );
$lause ="DELETE asiakas WHERE as_nimi = 'Bond, James Bond'";
$kyselyn_tulos = odbc_exec($lause, $yhteys)
if ( ! $kyselyn_tulos )
die (" Tietuetta ei voinut poistaa: ".odbc_error() );
print "<p>Tietue poistettu.";
odbc_close($yhteys);
?>
<html>
<head>
<title>Tietokantayhteyden avausesimerkki</title>
</head>
<body>
<?php
$kayttajatunnus = "mopsi";
$salasana = "nakki";
$tietokanta = "aivopesu";
// avataan yhteys
$yhteys = mysql_connect( "localhost", $kayttajatunnus, $salasana );
if ( ! $yhteys )
die( "MySQL -palvelimeen ei saanut yhteyttä!" );
print "Yhteys toimii, kylä lähtee!.<P>";
// valitaan tietokanta
mysql_select_db( $tietokanta )
or die ( "Tietokantaa $tietokanta ei voinut valita: ".mysql_error() );
print "Sain valittua tietokannan \"$tietokanta\", kyllä elämä on ihanata!<P>";
// laitetaan tietoa tietokantaan
$insert_lause ="INSERT INTO asiakas(as_nimi, as_puhnro, as_email)
VALUES ('Bond, James Bond', '555-BOND', 'james.bond@licence2kill.org')";
mysql_query($insert_lause, $yhteys)
or die ( "asiakas -tauluun ei voinut lisätä tietoa.<br>" );
print "Lisäys asiakas -tauluun onnistui.<br>";
// haetaan tietoa tietokannasta
$select_lause ="SELECT * FROM asiakas";
$lauseen_tulos = mysql_query($select_lause, $yhteys)
or die ( "asiakas -taulusta ei voinut hakea tietoa.<br>" );
while ( $rivi = mysql_fetch_row( $lauseen_tulos ) )
{
print "<tr>\n";
foreach ( $rivi as $kentta );
print "\t<td>$kentta</td>\n";
print "</tr>\n";
}
print "</table>\n";
// päivitetään tietokannan tietoja
$update_lause ="UPDATE asiakas SET as_email = 'austin.powers@shag-a-delic.org.asm'";
$kyselyn_tulos = mysql_query($update_lause, $yhteys);
if ( ! $kyselyn_tulos )
die (" Asiakas -taulua ei voinut päivittää: ".mysql_error() );
// poistetaan tieto taulusta
$delete_lause ="DELETE asiakas WHERE as_nimi = 'Bond, James Bond'";
$kyselyn_tulos = mysql_query($delete_lause, $yhteys)
if ( ! $kyselyn_tulos )
die (" Tietuetta ei voinut poistaa: ".mysql_error() );
print "<p>Tietue poistettu.";
mysql_close( $yhteys );
?>
</body>
</html>
<html>
<head>
<title>Tietokantayhteyden avausesimerkki</title>
</head>
<body>
<?php
$kayttajatunnus = "mopsi";
$salasana = "nakki";
$tietokanta = "aivopesu";
// avataan yhteys
$yhteys = odbc_connect( $tietokanta, $kayttajatunnus, $salasana );
if ( ! $yhteys )
die( "odbc -tietokantaan ei saanut yhteyttä!" );
print "tietokanta toimii.<P>";
// laitetaan tietoa tietokantaan
$insert_lause ="INSERT INTO asiakas(as_nimi, as_puhnro, as_email)
VALUES ('Bond, James Bond', '555-BOND', 'james.bond@licence2kill.org')";
odbc_exec($insert_lause, $yhteys)
or die ( "asiakas -tauluun ei voinut lisätä tietoa.<br>" );
print "Lisäys asiakas -tauluun onnistui.<br>";
// haetaan tietoa tietokannasta
$select_lause ="SELECT * FROM asiakas";
$lauseen_tulos = odbc_exec($select_lause, $yhteys)
or die ( "asiakas -taulusta ei voinut hakea tietoa.<br>" );
while ( $rivi = odbc_fetch_row( $lauseen_tulos ) )
{
print "<tr>\n";
foreach ( $rivi as $kentta );
print "\t<td>$kentta</td>\n";
print "</tr>\n";
}
print "</table>\n";
// päivitetään tietokannan tietoja
$update_lause ="UPDATE asiakas SET as_email = 'austin.powers@shag-a-delic.org.asm'";
$kyselyn_tulos = odbc_exec($update_lause, $yhteys);
if ( ! $kyselyn_tulos )
die (" Asiakas -taulua ei voinut päivittää: ".odbc_error() );
// poistetaan tieto taulusta
$delete_lause ="DELETE asiakas WHERE as_nimi = 'Bond, James Bond'";
$kyselyn_tulos = odbc_exec($delete_lause, $yhteys)
if ( ! $kyselyn_tulos )
die (" Tietuetta ei voinut poistaa: ".odbc_error() );
print "<p>Tietue poistettu.";
odbc_close( $yhteys );
?>
</body>
</html>
| Sisällysluettelo |
|