PHP HELT UTAN EKOLOGISKA TILLSATSER. Påhittad av

Transkript

1 PHP HELT UTAN EKOLOGISKA TILLSATSER Påhittad av

2 Innehåll PHP... 4 Hur PHP fungerar i en webbserver... 5 Använda PHP... 6 Syntax... 7 Variabler... 7 Datatyper... 7 Operatorer... 8 Konstanter... 9 Utmatning av text print och echo Funktionen printf Kommentarer Flödeskontroll if else Större if / else switch / case / default / break Upprepningar while for Funktioner Referensmanual Strängar Strängfunktioner Egna funktioner Arrayer Indexerade arrayer Lägga till, uppdatera och plocka bort värden Initiera arrayer med egendefinierade index foreach Associativa arrayer Flerdimensionella arrayer Formulär HTTP GET

3 HTTP POST Hantera formulär med PHP Skriva tillbaka värden Funktionen filter_var HTTP-headers Hantera HTTP-Headers med PHP Request Response Filhantering Skriva till en fil Läsa från en fil Kataloghantering Filuppladdning Inkludera filer Inkludera filer dynamiskt Sessioner Starta en session Ta bort en session Tidsbestämma en session

4 PHP PHP är ett programmeringsspråk utvecklat framförallt för att användas i samband med dynamiska hemsidor/webbapplikationer, även om det finns fler användningsområden som det här häftet inte ämnar att gå in på. Några av världens absolut största hemsidor använder sig idag av PHP och det är sedan flera år tillbaka ett av de vanligaste programspråken inom webbutveckling. Att lära sig grunderna i PHP är förrädiskt enkelt, och att komma igång och snabbt få ihop något som fungerar är en mycket snabbare process än att sätta sig in i många av de konkurerande programspråken på marknaden. Vid en första anblick liknar PHP i stort en blandning av programspråken C och Perl, men i och med PHP 5.0 som kom ut redan 2004 tog PHP ett definitivt steg i riktningen mot att bli ett mer objektorienterat språk. Men, till skillnad mot exempelvis de helt objektorienterade språken C# och Java, som PHP till viss del konkurerar med på marknaden för webbapplikationer, är inslagen av objektorientering fortfarande en frivillig del av språket. Utvecklingen av PHP leds sedan flera år tillbaka till stor del av det israeliska företaget Zend, även om den grönländska programmeraren Rasmus Lerdorf, som en gång i tiden skapade vad som idag har lite gemensamt med dagens PHP, fortfarande finns med och styr. Då PHP är öppen källkod och gratis att använda finns det också en uppsjö utvecklare, både fristående och anställda på olika företag, som regelbundet bidrar till PHPs kodbas. PHP står nu mera officiellt för den rekursiva akronymen PHP Hypertext Preprocessor, vilket är aningen missvisande då PHP som nämndes i inledningen idag kan användas för andra syften än att utveckla hemsidor. Även om det här kompendiet ligger på en nybörjarnivå där så gott som alla exempel lika väl går att använda i något äldre versioner av PHP är det rekommenderat att du som läser detta har en installation av PHP version 5.2 eller nyare. Kompendiet är gratis och får kopieras upp hur mycket som helst, men det finns alltid en PDF-version tillgänglig också. 4

5 Hur PHP fungerar i en webbserver En sida med PHP exekveras på webbservern och levereras till klienten, användaren bakom en webbläsare, i form av ett HTML-dokument - även om det är fullt möjligt att med PHP leverera annan typ av data också, som en bild eller ett PDF-dokument. Webbservern ser skillnad på olika typer av dokument beroende på vilken filändelse de har. En ren HTML-sida slutar vanligen med ".html" och levereras till klienten rätt upp och ner som den är skriven, medan en PHP-sida oftast har filländelsen ".php" vilket gör att webbservern först skickar sidan till PHP-motorn innan den levereras till klienten. Det är viktigt att förstå att det är upp till webbservern att bestämma vilken typ av fil det är som levereras - det är inte ovanligt att utvecklare döljer att de kör PHP genom att ställa in webbservern så att en annan filändelse än ".php" tolkas som PHP-kod. Nedan demonstrerar skillnaden mellan ett statiskt HTML-dokument (till vänster) och en fil med PHP (till höger). Även om vi inte än har börjat gå igenom syntaxen i PHP är det troligen relativt uppenbart att PHP-dokumentet skriver ut den aktuella tiden på servern när filen anropas, Filerna på servern <html> <body>hej!</body> </html> C:\www\hello.html <html> <body> Hej! Tid på servern just nu: print date("y-m-d, H:i");?> </body> </html> C:\www\hello.php Hur ett anrop till hello.html tolkas 1. Klienten surfar in på 2. Webbservern ser att filen slutar med ".html" och levererar ett statiskt HTML-dokument Hur ett anrop till hello.php tolkas 1. Klienten surfar in på 2. Webbservern ser att det filen slutar med ".php" och skickar dokumentet till PHP-motorn 3. PHP-motorn exekverar dokumentet och utför alla instruktioner inom?> 4. Webbservern levererar till användaren vad PHP-motorn spottar ut Vad webbservern faktiskt skickar till klienten <html> <body>hej!</body> </html> <html> <body> Hej! Tid på servern just nu: , 10:12 </body> </html> 5

6 Använda PHP Som föregående sida troligen avslöjade skrivs PHP-kod inom speciella "PHP-taggar" som PHP-motorn sedan tolkar. Fördelen med att kunna blanda PHP och HTML huller om buller är att det är väldigt enkelt att förstå sig på, men nackdelen - som i många fall vida överväger fördelen - är att ett dokument som ofta hoppar fram och tillbaka mellan PHP och HTML kan bli svåröverskådliga när de växer sig stora. Det finns en uppsjö olika lösningar för att separera PHP (logik) och HTML (layout), dock ingen inbyggd som följer med PHP, och vi kommer heller inte till en början att bry oss om detta problem. Förutom den redan bekanta konstruktionen?> som användes på förra sidan finns det ytterligare ett antal sätt att gå in i PHP-läge i ett PHP-dokument. Följande PHP-dokument skriver förmodligen ut strängen "Hello world" från PHP fyra gånger, <html> <body> Variant 1 : print "Hello world"?><br /> Variant 2 : <? print "Hello World"?><br /> Variant 3 : <?= "Hello World";?><br /> Variant 4 : <script language="php"> print "Hello world"; </script> </body> </html> Så vilken variant av dessa bör vi använda? Den översta, alltid! Variant två och tre är visserligen aningen kortare att skriva, men beroende på inställningar på webbservern så kan de ibland vara avstängda, det vill säga PHP-motorn kommer ignorera dem och programkoden skrivs då istället ut i webbläsaren som om det vore ren HTML. Genom att alltid använda?> kan vi försäkra oss om att vår PHP-kod alltid kommer köras, oavsett vilka konstiga inställningar som webbhotellet som kunden använder sig av har. Den sista varianten är väldigt obskyr och sällan förekommande, och det är inte helt omöjligt att den precis som "<??>" kommer fasas ut och plockas bort i nästa stora version av PHP - PHP 6.0. Zend rekommenderar att filer som bara innehåller PHP-kod inte bör avslutas med?> för att "stänga" PHP-dokumentet. PHP-motorn fungerar lika bra även utan en avslutande?> när det inte finns någon efterföljande HTML, och man undviker att av misstag få med sig en radmatning eller ett mellanslag efteråt, något som kan få konsekvenser om filen är en del av ett större system som är beroende av att ingen utmatning skickas till klienten. Vi kommer återkomma till det här problemet längre fram. Nu när vi vet hur PHP exekveras och kan användas är det dags att titta på syntaxen. 6

7 Syntax PHP har precis som många andra stora språk en syntax baserad på programspråket C, en så kallad C- syntax, och är i ett första skede relativt enkel att lära sig, speciellt om man jobbat med något annat programspråk med C-Syntax tidigare (som exempelvis Javascript). Ett PHP-dokument har i likhet med just Javascript ingen speciell funktion eller markör som visar var dokumentet skall starta, utan exekveringen börjar alltid högst upp. Variabler Variabler i PHP skrivs med ett inledande dollartecken och är löst typade, det vill säga en variabel behöver inte deklareras i förväg som en viss datatyp (som en sträng, ett heltal, etc) utan PHP kommer automatiskt hålla reda på vilken datatyp variabeln har för tillfället. Det är till skillnad mot starkt typade språk alltså inga problem att byta en variabels datatyp under körning. Namn på variabler måste efter dollartecknet börja med en bokstav eller ett däckat minustecken (_) och är skiftkänsliga, det vill säga variabeln $database är inte samma som $DataBase. Även om det är möjligt att använda skandinaviska bokstäver i variabelnamn är det rekommenderat att använda engelska namn ($age istället för $ålder exempelvis), då engelska är att betrakta som branschstandard. Datatyper Även om PHP är ett löst typat språk innebär det inte att datatyper inte finns, naturligtvis. I PHP har vi följande inbyggda skalära datatyper, string - En teckensträng med data, ofta bokstäver bool - En boolesk datatyp, alltså antingen värdet sant (true) eller falskt (false) int - Ett heltal float - Ett flyttal (decimaltal) Sammansatta datatyper, alltså data som kan representera sig genom att använda andra datatyper (vi återkommer till dessa datatyper senare), array - En vektor eller "lista" med data object - Ett objekt med data Speciella datatyper, resource - Någon typ va resurs, exempelvis en öppen fil eller anslutningen till en databas null - Avsaknad av data, en "tom" (odefinierad) variabel $name = "Leonard Skalbagge"; // Skapar en string $insect = true; // Skapar en bool $answer = 42; // Skapar en int $pi = 3.14; // Skapar en float $colors = array("r", "G", "B"); // Skapar en array $nothing = null; // Skapar en variabel utan ett värde Exempel på variabler med olika datatyper 7

8 Operatorer Operatorer används för att utföra beräkningar, jämförelser och för att tilldela värden. Ett typiskt exempel skulle kunna vara att använda additionsoperatorn - eller "plus" som vi vanliga människor säger - för att slå ihop två variabler med heltalsvärden och få ut summan, 42 $x = 35; $y = 7; $answer = $x + $y; print $answer; De flesta operatorer fungerar som väntat precis som i de flesta andra programmeringsspråk baserat på C-syntax, men det finns tre stycken tillägg i PHP som är viktiga att känna till; operatorn för att konkatenera strängar, som avhandlas i slutet på nästa sida, och de två extra jämförelseoperatorerna, === och!===, som används för att testa mot både värde och datatyp. Som tidigare har nämnts är PHP ett löst typat språk och jämförelser mellan olika värden är minst sagt godtyckligt. Exempelvis anses texten "0.00" vara identisk med heltalet 0, om jämförelsen görs med den vanliga operatorn för att jämföra två värden i C-syntax, alltså två likamedtecken. Likaså är samtliga heltal utom 0 att betrakta som det booleska värdet true, och det odefinierade värdet null beräknas alltid som false, if (10 == true) // Ja, värdet 10 är att betrakta som true print "10 är true"; else print "10 är false"; 10 är true PHP är långt ifrån det enda språket där olika datatyper automatiskt konverteras till ett booleskt värde vid en jämförelse, och är man bara medveten om det brukar det inte göra så mycket, men i de fallen då vi vill räkna med datatypen också för att verkligen försäkra oss om att två värden är identiska måste vi som sagt använda oss av ytterligare ett likamedtecken, if (10 === true) // Nej, datatyperna stämmer inte (int och bool) print "Test 2 OK"; else print "10 är false"; 10 är false Det här kan tyckas som ett mindre viktigt problem att behöva hålla koll på, men det kommer uppstå flera tillfällen då vi behöva testa exakta värden, vanligen att en variabel faktiskt är false och inte heltalet noll (den otålige kan bläddra vidare till avsnittet om strängfunktioner för ett exempel på det). 8

9 Konstanter En konstant är i PHP en textsträng associerat med ett visst värde. En konstant har andra användningsområden än en variabel; precis som namnet antyder så är en konstant just konstant, efter att vi deklarerat en konstant med ett värde är det omöjligt att i efterhand ändra den. Det innebär också att en konstant alltid har ett värde, det är med andra ord inte möjligt att skapa en konstant utan ett värde. Konstanter blir automatiskt globala, vilket innebära att de till skillnad från vanliga variabler bli tillgängliga överallt i programmet så fort de är deklarerade. En konstant skapas med hjälp av konstruktionen define och skrivs som standard alltid med versaler enligt följande, define("max_monkeys", 99); // Notera att vi måste ha "" runt namnet $monkeys = 400; if ($monkeys > MAX_MONKEYS) print "För många apor ombord, max tillåtna: ". MAX_MONKEYS; För många apor ombord, max tillåtna: 99 Konstanter skiljer sig från variabler i och med att de inte har $ före sitt namn, men i övrigt delar de namnreglerna för variabler vilket innebär att de exempelvis inte får börja med en siffra eller ha ett mellanslag i namnet. Jämfört med variabler är konstanten ett sällsynt djur i de flesta program, för det mesta används de för att deklarera globala värden och inställningar som tack vare att de är deklarerade på ett enda ställer är lätt att uppdatera i framtiden. PHP har förutom en mängd fördefinierade konstanter som vi kommer stifta bekantskap med längre fram i samband med olika funktioner också ett par "magiska" konstanter för metadata. De kallas så därför att de är konstanter i den meningen att de ser ut som konstanter och har ett fast värde som inte går att ändra på, men värdet i sig är dynamiskt och är beroende på var i källkoden de används. De magiska konstanterna känns igen på att de alla börjar och slutar med " ", print "Det här är filen: ". FILE. ", rad: ". LINE Det här är filen: /home/httpd/vhosts/default/test.php, rad: 3 För att undvika krockar rekommenderas det att man undviker att skapa egna konstanter som börjar och slutar med " ". 9

10 Utmatning av text Strängar med text skapas med citationstecken eller enkel apostrof och kan sträcka sig över flera rader. Skillnaden mellan att använda citationstecken och apostrof när vi skapar strängar ligger i hur variabler och så kallade escape-koder (se nedan) hanteras i dem. En sträng skriven med apostrofer upphäver alla variabler och samtliga escape-koder förutom \\ och \'. Escape-koder, ibland kallade escape-sekvenser, är speciella markeringar efter ett bakåtsträck för att lägga in vissa tecken och styrkoder som inte lätt går att skriva för hand, exempelvis \n - En radmatning \$ - Ett dollartecken (eftersom vanligt $ används för att markera en variabel vanligen) \\ - Ett bakåtsträck \" - Ett citattecken, endast för strängar inom citationstecken \' - En apostrof, endast för strängar inom apostroftecken Det kan vara värt att notera att \n gör ett faktiskt enterslag i strängen, något som - såvida texten inte är omsluten med <pre> - inte ger en radmatning i HTML. print och echo För att faktiskt skriva ut något till klienten, alltså webbläsaren, används vanligen en av de två konstruktionerna echo eller print som fungerar nästan likadant. Den subtila skillnaden ligger i att print uppför sig mer som en så skallad funktion i PHP, medans echo är en marginellt snabbare konstruktion. Vilken man använder är mer eller mindre en estetisk smakfråga. Nedan visar ett exempel med skillnaden mellan att använda citationstecken och apostrofer för att skapa strängar, $firstname = "Guybrush"; $lastname = "Threepwood"; $complete = "$firstname $lastname"; print " My name is \"$complete\", and I'm a mighty pirate!\n"; print 'My name is "$complete", and I'm a mighty pirate!\n'; Welcome! My name is "Guybrush Threepwood", and I'm a mighty pirate! Welcome! My name is "$complete", and I'm a mighty pirate!\n För att konkatenera ("slå ihop") strängar används, något ovanligt, en punkt, medans plustecknet används för addition mellan två tal. En situation att vara uppmärksam på är när en sträng slås ihop och aritmetiska operatorer (räknesätt) används i ett och samma uttryck. Vid sådana tillfällen har punktoperatorn högre prioritet, alltså utförs det före plustecknet, något som kan ställa till problem, 15 $x = 10; $y = 5; print "$x + $y = ". $x + $y; 10

11 Anledningen till varför exemplet på förra sidan bara skrev ut "15" och inte vad vi kanske förväntade oss, " = 15", är för att PHP först lägger ihop "$x + $y = ". $x innan den adderar med $y. Alltså är uträkningen på förra sidan samma sak som om vi hade skrivit, 15 $y = 5; print " = 10" + $y; I mindre dynamiska programmeringsspråk hade en sådan uträkning gett ett fel, men istället försöker PHP räkna så gott det går genom att plocka ut alla siffror i början på strängen (10) och addera det med värdet av variabeln $y (5), vilket då ger utskriften 15. Om du tycker det är snurrigt så kan du trösta dig med att det ändå är relativt sällan som det här scenariot uppstår. Hur som helst, för att lösa det här problemet får vi precis som i matematikens värld omsluta de uträkningar som först skall utföras med parenteser, vilket då ger, print "$x + $y = ". ($x + $y); = 15 // Räkna ut additionen först Funktionen printf Ett alternativ till konstruktionerna print och echo är att använda funktionen printf. Funktionen printf skriver precis som print och echo ut en sträng med text, men kan istället för att baka in variabler direkt i strängen också använda markörer som sedan fylls i med rätt värden genom att man lägger till dem på slutet. Det är inte fullt så krångligt som det låter, nedan ett exempel som använder både print och printf för att åstadkomma samma sak, $name = "Spindeln Glenn"; print "I am $name, I rule the world!"; printf("i am %s, I rule the world!", $name); I am Spindeln Glenn, I rule the world! I am Spindeln Glenn, I rule the world! Istället för att spränga in variabeln i texten som i print använder vi %s som en markör för att "här skall det in en sträng" som sedan fylls på i slutet. Funktionen printf är relativt avancerad och har mängder av olika formateringsmöjligheter, men de absolut vanligaste markörerna är %s för text, %d för heltal och %f för flyttal. Notera att med printf måste texten och efterföljande argument stå inom parenteser, något som är frivilligt när man använder print och echo. 11

12 I exemplet på förra sidan är det tveksamt om vi vinner något på att använda printf då texten är så väldigt simpel. I mer avancerade utmatningar som innehåller exempelvis beräkningar kan printf vara att föredra då det kan användas för att undvika prioriteringsproblematiken med punktoperatorn, vilket också kan göra programkoden med lättläst. Nedan följer en simpel uträkning av vad 451 grader Fahrenheit är i motsvarande grader Celsius, $fahrenheit = 451; print "$fahrenheit F = ". (($fahrenheit - 32) / 1.8). " C"; 451 F = C Även om svaret är korrekt måste vi dels öppna och stänga strängen för att få med uträkningen så att den inte tolkas som text, dels måste uträkningen vara grupperad inom parenteser för att få högre prioritet än punkten, och slutligen finns det inget vi kan göra för att begränsa antal decimaler. Med hjälp av printf kan vi börja lösa alla dessa problem, printf("%s F = %s C", $fahrenheit, ($fahrenheit - 32) / 1.8); 451 F = C Genom att bryta ut variablerna har vi flyttat uträkningen till slutet av strängen och behöver inte längre gruppera den inom extra parenteser, annat än subtraktionen då uträkningen annars först skulle räkna 32 dividerat med 1.8 eftersom division har högre prioritet inom matematiken. För att få ner antalet decimaler kan vi byta ut den sista markören från %s (text) till exempelvis ett heltal (%d), printf("%s F = %d C", $fahrenheit, ($fahrenheit - 32) / 1.8); 451 F = 232 C Men vänta lite nu, borde det inte stå 233? Nej, %d avrundar inte utan läser värdet " " från vänster till höger tills den kommer till första tecknet som inte är en siffra. För att faktiskt avrunda talet kan vi byta markören till %f (för flyttal) och med en aningen knepig syntax säga att v i vill ha det avrundat till två decimaler, printf("%s F = %.2f C", $fahrenheit, ($fahrenheit - 32) / 1.8); 451 F = C Det är också fullt möjligt att få det bästa av båda världar, printf("$fahrenheit F = %.2f C", ($fahrenheit - 32) / 1.8); 451 F = C Så vad skall vi använda, print, echo eller funktionen printf? Rekommendationen är att vanligen välja en av print eller echo då de är enklare och snabbare än printf, men att använda printf när det gör programkoden mer lättläst eller vi behöver använda någon av dess formateringsfunktioner. 12

13 Kommentarer Svenska språket är fantastiskt, men i större projekt bör dokumentation och kommentarer i källkoden alltid vara på engelska, det är branschstandard och lika bra att få in i huvudet direkt. Det är en global bransch och vi kan aldrig veta vilka som kommer att ta över eller hjälpa till i framtiden. Förutom de vanliga sätten att kommentera sin källkod, hämtade från C och C++, kan man i PHP även använda nummertecknet (#) för att kommentera ut en enstaka rad, något PHP lånat från scriptspråk vanligt förekommande på UNIX-system. Det gör att det inte finns mindre än tre sätt att kommentera sin källkod i PHP, // En så kallad C++-kommentar som kommenterar ut allt till slutet av raden # En så kallad script-kommentar, fungerar likadant som C++-kommentaren /* En så kallad C-kommentar som kan sträcka sig över flera rader */ Så vilken variant bör vi använda? Vi kan först konstatera att kommentarer med # är relativt ovanligt när man använder PHP för att bygga hemsidor. Större projekt har ofta en standard som dikterar hur kommentarer skall skrivas, och då skall den naturligtvis följas, men för egna projekt brukar jag rekommendera att man använder // för att dokumentera sin källkod. Det gör att man i efterhand, om så skulle behövas, snabbt kan kommentera bort stora block med programkod med hjälp av /* */ utan att dokumentationen är i vägen, då kommentarer gjorda med /* */ inte kan vara nästlade i varandra. En fråga som dyker upp med jämna mellanrum är hur mycket man skall kommentera sin källkod. Det finns inget definitivt svar på den frågan, men en bra grundregel är att försöka undvika att kommentera hur källkoden fungerar, och istället dokumentera varför den fungerar. Eller med andra ord, utgå alltid från att den personen som kommer läsa källkoden kan programspråket, det är inte ditt jobb att dokumentera hur språket fungerar (såvida du inte skriver källkoden i utbildande syfte naturligtvis, exempelvis som en del av ett kompendium). Det här är ett exempel på en fullständigt värdelös kommentar som bara tar upp plats, $x += 10; // Increase x with 10 Vi kan utgå att personen som läser källkoden inte behöver någon hjälp med att förstå att variabeln x ökar med 10. Men, är det inte från källkoden direkt uppenbart varför x ökas med 10 kan det vara bra att dokumentera däremot, $x += 10; // Compensate for the heat from the flux capacitor Kommentarer är aldrig någon ursäkt för att skriva svårlästa applikationer, så om du märker att du måste kommentera din källkod för att förstå den är det högst troligt att en bättre lösning är att skriva om källkoden. Välskriven källkod dokumenterar ofta sig självt. 13

14 Flödeskontroll Flödeskontroll, eller "styrstrukturer" som vissa översätter det med, handlar om att styra ett programs flöde genom att utvärdera uttryck som sanna eller falska och därefter dirigera förloppet. if Precis som andra C-baserade språk använder PHP den vedertagna if-satsen som i sitt enklaste testar ett enskilt uttryck och utför nästkommande sats (statement på engelska), $x = 21; if ($x < 42) print "Variabeln x är under 42"; Variabeln x är under 42 Det är viktigt att förstå att if alltid utvärderar om uttrycket är sant eller falskt, ovanstående fungerar just därför att uttrycket $x < 42 returnerar ett booleskt true. Hade vi vänt på operatorn, alltså $x > 42 istället, hade uttrycket returnerat false och print-satsen hade inte utförts. else En efterföljande konstruktion på en if-sats är else, som helt enkelt utförs om det första värdet inte är sant, $x = 84; if ($x < 42) print "x är under 42"; else print "x är 42 eller över"; Variabeln x är 42 eller över Genom att kombinera if och else kan vi bygga vidare och på så sätt testa för flera olika scenarion istället för bara ett ja/nej, $x = 42; if ($x < 42) print "x är under 42"; else if ($x > 42) print "x är 42 eller över"; else print "x är exakt 42"; Variabeln x är exakt 42 14

15 Större if / else I samtliga tidigare exempel på förra sidan har vi använt endast en programsats efter varje uttryck. Vill vi utföra flera än det måste vi gruppera dem inom och, enligt följande, $user = "Stephen Falken"; if ($user == "Stephen Falken") // Skriver ut två rader print "Greetings Professor Falken.\n"; print "Shall we play a game?"; else if ($user == "Sam Bell") // Kommentarer räknas inte som programkod, behövs inte här print "Good morning Sam, shall I cut your hair today?"; else print "<b>access Denied</b>, I don't know you o O;"; Greetings Professor Falken Shall we play a game? Skulle vi glömma klamrarna i exemplet ovan kommer PHP att vägra köra koden och spotta ut sig felmeddelande då en else aldrig kan stå ensamt utan måste vara kopplad till en if. Med andra ord, utan kommer PHP tolka ovanstående såhär,... if ($user == "Stephen Falken") print "Greetings Professor Falken.\n"; // Här slutar if print "Shall we play a game?"; else if ($user == "Sam Bell")... Parse error: syntax error, unexpected T_ELSE // Felaktig syntax, else utan tillhörande if! Ett vanligt slarvfel är att råka skriva = (tilldelning) istället för == (jämförelse) i en if. Då PHP är ett språk som anser att strängar som inte är tomma och heltal som inte är 0 är att betrakta som "sant" kommer en sådan miss inte ge något felmeddelande, men programkoden kommer heller inte att fungera som man (troligen) har tänkt sig. Istället för att jämföra variabeln kommer den tilldela den ett värde och därefter utvärdera resultatet av operationen. Alltså kommer, if ($user = "Stephen Falken") för if att utvärderas som om vi hade skrivit, if ("Stephen Falken")...vilket, innebär - då PHP tolkar strängen "Stephen Falken" som true - att if alltid kommer köras så länge som $user inte är exempelvis en tom sträng, vilken då räknas som false. 15

16 switch / case / default / break Ett alternativ till if / else if / else är switch-satsen. För det mesta är switch bara en estetisk variant på att utvärdera ett fast värde mot flera olika alternativ - det vill säga användandet av en switch gör ofta bara programkoden mer läsbar jämfört med en if då den tar upp mer plats vertikalt än horisontellt. Nedanstående två kodsnuttar gör exakt samma sak, men if är mer kompakt och svårläst medan switch å andra sidan både är mer lättläst och kan utan att tumma på läsbarheten växa med fler värden att jämföra med i framtiden. $user = "Deckard"; if ($user == "Roy" $user == "Priss" $user == "Leon") print "$user is a replicant."; else if ($user == "Deckard") print "$user might be a replicant."; else print "$user is a human."; Deckard might be a replicant. $user = "Deckard"; switch($user) case "Roy": case "Priss": case "Leon": print "$user is a replicant."; break; case "Deckard": print "$user might be a replicant."; break; default: print "$user is a human."; Deckard might be a replicant. Konstruktionen break, som hoppar ur en case (fungerar även för att lämna loopar), liksom den avslutande default (synonymt med else i en if) är inte tvingande. Skulle vi glömma att skriva en break skulle exekveringen fortsätta ner till nästa case. Alltså, skulle vi exempelvis plocka bort den första breaksatsen och $user var satt till "Roy" skulle båda de två första print-satserna utföras, eftersom det inte finns något som stoppar. Det är relativt sällan som funktionaliteten med att ramla ner till nästa nivå i en switch används, och att glömma break-satser är ett vanligt förekommande logiskt fel som inte uppstår förrän den delen av programkoden provkörs. 16

17 Upprepningar Förutom de mest triviala program finns det nästan alltid behov av att upprepa programkod enligt formulan "utför x tills y", ett typsikt exempel skulle kunna vara att läsa rad för rad från en fil med text tills det inte längre finns några rader kvar. while Konstruktionen while, eller while-loopen som man brukar säga, fungerar i praktiken som en if-sats, men med skillnaden att den upprepar sig själv och koden den omsluter tills uttrycket inte längre är sant, $x = 8; while($x < 10) // Så länge som x är under print "\$x = $x\n"; $x++; $x = 8 $x = 9 for Då många upprepningar följer ett distinkt mönster: 1 sätt ett initialt värde, 2 upprepa tills värdet når en viss punkt, 3 uppdatera värdet för varje iteration (i exemplet ovan x = 8, x < 10, x++) finns som alternativ till while-loopen den mer kompakta och använda for-loopen som tar formen, for( initiala värden att tilldela ; uttryck att utvärdera ; att utför efter varje iteration) programkod som körs för varje iteration För att spara plats skrivs for-loopen på en rad, vilket gör att om vi skulle skriva om while-loopen ovan som en for-loop hade den se ut så här, for($x = 8; $x < 10; $x++) print "\$x = $x\n"; $x = 8 $x = 9 Till skillnad mot while-loopen är samtliga tre argument i en for-loop frivilliga, det är med andra kord korret syntax att skriva exempelvis for ( ; ; ), vilket ger en for-loop som aldrig stannar eftersom det saknar ett uttryck att utvärdera. 17

18 Funktioner En funktion är, som det låter, funktionalitet som följer med PHP-installationen och kan vara allt från att läsa från och skriva till databaser som att räkna ut hur många tecken en text innehåller. PHP har två distinkta typer av funktioner; inbyggda funktioner som alltid finns tillgängliga och externa funktioner som inte är en del av PHP utan som ligger i separata bibliotek (i so-filer under UNIX och DLLfiler under Windows). Skillnaden för oss som utvecklare är att vi alltid kan vara säkra på att inbyggda funktionerna finns tillgängliga medan det kan vara värt att kontrollera vad som finns installerat på webbhotellet innan vi börjar utveckla något som kräver ett mer exotiskt bibliotek, typ funktionerna för att skapa PDF-filer. Ofta är det här inte något stort problem, de flesta externa funktioner som är vanligt förekommande, som MySQL för att prata med den vanliga databasen MySQL eller GD för att rita och manipulera bilder med PHP, är nästan alltid installerade. Naturligtvis är det här en total ickefråga om kunden har en egen dedikerad servern där vi har full tillgång till en egen PHP-installation och kan installera ny funktionalitet efter behov, utan att vara bunden till vad ett visst webbhotell har valt att ha med i sin standardkonfiguration. På grund av att PHP har utvecklats från att ha varit ett väldigt simpelt språk till vad det är idag, utan att göra någon större avkall på bakåtkompabilitet, så är det rent ut sagt ganska rörigt och det finns ofta fler olika sätt att göra samma sak. Felhanteringen för många funktioner är tyvärr bedrövlig i jämförelse med mer moderna språk, exempelvis är det vanligt att en funktion som anropas felaktigt, eller av någon annan anledning misslyckas, skriver ut ett felmeddelande direkt till webbläsaren, printf("%s"); Warning: printf() Too few arguments Om möjligt är naturligtvis den bästa lösningen att helt enkelt skriva koden så att inga fel uppstår, men ibland är det omöjligt att garantera att programkoden kommer fungera, exempelvis om man försöker ansluta mot en databas som just för tillfället inte är online. Den något ovanliga lösningen på problemet är att skriva framför funktionen, vilket instruerar PHP att temporärt stänga av utskrifter av felmeddelande för just den funktionen. Referensmanual PHPs officiella hemsida har bra och lättläst dokumentation över så gott som alla funktioner som finns tillgängliga. Istället för att manuellt gå igenom manualen på hemsidan och klicka sig fram till rätt funktionsnamn räcker det sedan några år tillbaka att bara skriva i webbläsaren för att hemsidan automatiskt skall hoppa till dokumentationen för den funktionen man vill åt. Exempelvis ger dokumentationen för funktionen printf. Att lära sig använda manualen på hemsidan är en viktig del i att utveckla effektivt med PHP då de flesta funktionerna, förutom en beskrivning över vad de gör, också ofta innehåller både direkta exempel över hur de kan användas och kommentarer från andra PHP-användare (det bör visserligen också understrykas att många av kommentarerna är av högst skiftande kvalitet och ibland rent ut sagt helt åt skogen, caveat lector). 18

19 Strängar Strängar i PHP har, på gott och ont, en hel del gemensamt med programspråket C då de precis som C, som egentligen inte har strängar utan mera vektorer av tecken, inte tar hänsyn till eventuell teckenuppsättningar utan hanterar all text som vilken data som helst. Andra, ofta nyare, programspråk som inte växt fram fullt så organiskt som PHP hanterar gärna textdata separat från annan data, något som underlättar när en textsträng har en annan teckenuppsättning än den vanliga och simpla västerländska teckenuppsättningen ISO , där varje tecken representeras av en byte och sålunda också är begränsad till 255 olika tecken. Så länge som vi använder oss av det amerikanska alfabetet som inte har några exotiska tecken som å, ä och ö, är det här inga problem, det är först när en teckenuppsättning som exempelvis den universella UTF-8 kommer in i bilden, där å ä och ö representeras av två byte istället för en, som det här kan ställa till problem i PHP. Nedanstående illustration visar order "Räksmörgås", först i ISO och sedan i UTF-8., Vi kan i illustrationen ovan se att ISO och UTF-8 är identiska så länge som vi håller oss till det engelska alfabetet, eller sagt på ett annat sätt, för en person utan "konstiga" tecken i sitt alfabet spelar det ingen roll vilken av teckenuppsättningarna de använder - rent datamässigt kommer deras dokument vara identiskt. Skillnaden uppstår först vid tecknen å, ä och ö, där varje tecken istället för en byte beskrivs med två i UTF-8, vilket gör att rent storleksmässigt kommer ordet räksmörgås vara tre byte längre. För PHP, som alltså arbetar internt med strängar på byte-nivå precis som C och utan någon direkt kunskap om teckenuppsättningar, så kommer det innebära att ordet räknas som 13 "tecken" istället för det förväntade 10, och en funktion som exempelvis substr, som används för att klippa ut delar av strängar, skulle kunna klyva strängen så att R och halva ä (82, 195) hamnar på ena sidan, och resten av ä (164, och resten) hamnar på den andra, print substr("räksmörgås", 2); ksmörgås // Skriver ut från 2 byte och framåt. 19

20 Det här är ett problem i PHP eftersom en teckenuppsättning som UTF-8 är relativt populär idag, och en av nyheterna i nästa stora version av PHP, PHP 6.0, är att just stödet för teckenuppsättningar skall vara avsevärt förbättrat. Strängfunktioner Förutom den tidigare nämnda substr har PHP en uppsjö olika funktioner för att manipulera strängar och annan data (att PHP jobbar med strängar som vilken data som helst har fördelen att vi enkelt kan använda strängfunktionerna för att klippa och klistra även i annan data som inte är att betrakta som text). Nedan följer en kort sammanfattning av några av de vanligaste, för en komplett lista se manualen på under sektionen "String Functions", strlen Returnerar strängens längd $text = "Räksmörgås"; $length = strlen($text); print "Strängen $text består av $length tecken (eller bytes snarare)"; Strängen Räksmörgås består av 10 tecken (eller bytes snarare) substr klipper ut en del av en sträng, $text = "digital"; for ($i = 0; $i < strlen($text); $i++) print "[". substr($text, $i, 1). "]"; [d][i][g][i][t][a][l] strpos returnerar första positionen av en delsträng, eller false om delsträngen inte finns. Då första positionen i en sträng är 0, vilket PHP räknar som false, måste vi använda!== eller ===, $text = "Spindeln Glenn"; $find = "Glenn"; $pos = strpos($text, $find); if ($pos === false) print "Strängen '$find' finns inte i texten $text"; else print "Strängen '$find' återfinns på position $pos i texten '$text'"; Strängen 'Glenn' återfinns på position 9 i texten 'Spindeln Glenn' str_replace ersätter en del av en sträng med en annan, $text = "Spindeln Glenn körde försiktigt med sin pansarvagn."; $text = str_replace("försiktigt", "som en komplett dåre", $text); print $text; Spindeln Glenn körde som en komplett dåre med sin pansarvagn. 20

21 Egna funktioner Egendefinierade funktioner i PHP används dels för att kapsla in funktionalitet som går att återanvända på flera ställen och dels för att öka läsbarheten på programkoden. Funktioner definieras med ordet function följt av funktionens namn och eventuella argument som funktionen tar. Funktioner skrivs i PHP lämpligast på engelska och med gemener om de bara består av ett ord. Om funktionsnamnet består av flera ord brukar det rekommenderas att man skriver varje nytt ord efter det första med stor begynnelsebokstav. Funktionsnamn följer samma regler som variabelnamn och kan alltså inte innehålla exempelvis ett mellanslag. En bra riktlinje för att få lättläst källkod är att skriva små och enkla funktioner som bara har en uppgift, samt att namnge dem efter den uppgiften. Heter funktionen exempelvis "updateusername" skall funktionen bara uppdatera användarnamnet, den skall inte uppdatera namnet och sedan också göra massa annat. Med simpla funktioner blir inte bara källkoden mer lättläst eftersom det inte är någon tvekan vad funktionerna gör för något, de blir också enklare att återanvända eftersom de blir mer generella och inte är knutna till ett visst exakt scenario i källkoden. I sitt simplaste utförande tar funktionen inga argument och ser ut såhär, function sayhello() print "Hello!"; sayhello(); sayhello(); Hello! Hello! Funktionen sayhello har ett minst sagt tvivelaktigt existensberättigande. För att marginellt förbättra den kan vi modifiera så att den tar ett argument och skriver ut det tillsammans med hälsningsfrasen, function sayhello($name) print "Hello $name!"; sayhello("leonard Skalbagge"); sayhello("spindeln Glenn"); Hello Leonard Skalbagge! Hello Spindeln Glenn! Flera argument till funktioner går att separera med kommatecken. Skulle vi nu anropa funktionen som sayhello(), alltså utan att ange ett namn, så skulle vi få en varning från PHP att vi anropar funktionen utan rätt antal argument. Programmet skulle dock inte krascha, utan variabeln $name i funktionen skulle bli satt till det odefinierade värdet null. 21

22 Variabler definierade inuti en funktion är begränsade till funktionen och går inte att direkt komma åt utifrån, function sayhello($name) print "Hello $name!"; sayhello("leonard Skalbagge"); print $name; // Fel, en $name finns bara i sayhello() Hello Leonard Skalbagge! Notice: Undefined variable: name Likaså är variabler definierade utanför en funktion inte tillgängliga inuti i den, function sayhello() print "Hello $name!"; // Fel, finns ingen $name här inne! $name = "Leonard Skalbagge"; sayhello(); Notice: Undefined variable: name Hello! PHP tillåter inte att man deklarerar funktioner flera gånger med olika antal argument för att skilja dem åt (det kallas att överlagra funktioner i andra språk som tillåter det), däremot är det tillåtet att ange argument med standardvärden vilket gör att användaren kan välja om han eller hon vill skicka med argument eller inte, function sayhello($name = "") // $name får standardvärdet "" (tom sträng) if ($name == "") print "Hello everyone!"; else print "Hello $name!"; sayhello("leonard Skalbagge"); sayhello(); // Alltså samma som att skriva SayHello(""); Leonard Skalbagge Hello everyone! 22

23 I de tidigare exemplen har den fantastiska sayhello-funktionen skrivit ut en rad med text, och det är visserligen inget direkt fel i det, men det gör en sådan funktion begränsad i hur den kan användas. Studerar vi de inbyggda funktionerna i PHP ser vi att det är ytterst få som faktiskt skriver ut text till webbläsaren, istället returnerar de ofta ett värde som vi sedan kan välja att skriva ut. Låt säga att vi har en funktion som räknar ut arean på cirkel. Istället för att skriva ut arean direkt vore det naturligtvis mycket mer användbart att returnera tillbaka det korrekta värdet till användaren, som sedan kan välja hur utskriften skall bli, function getarea($radius) $area = $radius * $radius * 3.14; return $area; $area = getarea(7); printf ("Arean av en cirkel med radien 7cm är c:a %.1f cm", $area); Arean av en cirkel med radien 7cm är c:a 153.9cm Notera att det i exemplet ovan alltså finns två stycken helt olika variabler med namnet $area, en utanför funktionen och en inuti den, deras enda gemensamma punkt är att de råkar ha samma namn. En funktion kan ha mer än en return-sats i sig. Så fort en funktion når en return returneras värdet och funktionen avslutas, eventuell kod därefter kommer inte utföras. En funktion kan också använda en return utan ett efterföljande värde för att snabbt avsluta sig, function calculatesillystuff($x) if ($x < 0) print "argumentet x får inte vara negativt, nu skiter jag i det här!"; return; //... eventuell kod här kommer inte utföras om x < 0 23

24 Arrayer Arrayer, eller på svenska ibland kallade vektorer, är enkelt uttryckt en lista som håller ett antal värden, där varje värde ligger på en speciell position som anges antingen med en siffra eller en textsträng. Arrayer är ett centralt begrepp i PHP och används mer eller mindre överallt, varför det är ofrånkomligt att tvingas lära sig använda dem. Även om arrayer vid första anblicken kan kännas som aningen övermäktiga är de ändå ganska enkla att arbeta med jämfört med många andra programspråk. Indexerade arrayer En indexerad array är ett tjusigt namn för en array där varje värde i arrayen ligger i en numerisk ordning, så att första värdet ligger på index (position) 0, andra på index 1, tredje på 2, och så vidare. För att skapa en array används just också det reserverade ordet array, och även om det ser ut och måste användas precis som en funktion - där varje argument blir en del av arrayen - så är det alltså en del av programspråket PHP, $robots = array("gerty", "Wopr", "Skynet"); Ovanstående skapar en array i $robots med tre värden, där "Gerty" ligger på index 0, "Wopr" på 1, och "Skynet" på 2. Eftersom PHP traditionellt inte brukar utvecklas med hjälp av avancerade verktyg som klarar av att inspektera variabler medan ett program körs finns istället funktioner som print_r, som kan ta en array som argument och skriva ut till webbläsaren hur den är konstruerad, print_r($robots); Array ( [0] => Gerty [1] => Wopr [2] => Skynet ) Funktionen print_r är användbar för att analysera arrayer under tiden applikationen utvecklas, men är inte till någon större nytta annars. Vanligen vill man istället få ut eller använda något specifikt värde i en array, vilket man som utskriften från print_r skvallrar om, gör genom att använda klamrar, print "Robot 1: ". $robots[1]; Robot 1: Wopr 24

25 Till skillnad mot exempelvis Javascript är arrayer inte så kallade objekt, vilket innebär att de inte själva har någon information om exempelvis hur många olika värden de innehåller, utan istället får vi använda oss av funktionen count (eller sizeof, de är identiska) som tar en array som argument och returnerar antal värden. print "Antal robotar: 3". count($robots); Antal robotar: 3 Det är viktigt att komma ihåg att arrayen ovan har sitt första värde på index 0, vilket gör att även om vi har tre värden i den här arrayen ligger alltså sista värdet inte på 3, utan på 2. Skulle vi försöka skriva ut ett värde från ett index som inte finns skulle vi få en varning (programmet skulle dock inte stanna upp utan fortsätta), $robots = array("gerty", "Wopr", "Skynet"); // 0, 1, 2 $total = count($robots); // 3 print $robots[$total]; // FEL, finns inget värde på index 3 Notice: Undefined offset: 3 För att skriva ut alla värden från en indexerad array kan vi använda kunskapen att sista värdet ligger på det totala antalet - 1, och skriva en for-loop som börjar på noll och stegar uppåt så länge som den är under antalet värden i arrayen, for($i = 0; $i < count($robots); $i++) print "Robot $i: ". $robots[$i]. "\n"; Robot 0: Gerty Robot 1: Wopr Robot 2: Skynet 25

26 Lägga till, uppdatera och plocka bort värden Arrayer är väldigt dynamiska i PHP och kan utan problem modifieras i efterhand, något som är allt annat än självklart i många andra programspråk. Att lägga till ett nytt index i en array, vilket då ökar storleken på arrayen med ett, är inte svårare än att skriva indexet inom klamrar och tilldela det ett värde, $robots = array("gerty", "Wopr", "Skynet"); // Skapar index 0, 1, 2 print "Antal robotar innan: ". count($robots). "\n"; $robots[3] = "HAL 9000"; // Lägger till HAL 9000 på index 3 print "Antal robostar efter: ". count($robots). "\n"; print_r($robots); Antal robotar innan: 3 Antal robotar efter: 4 Array ( [0] => Gerty [1] => Wopr [2] => Skynet [3] => HAL 9000 ) För att lägga till ett nytt värde i en array på nästa lediga index kan vi helt enkelt utesluta att ange ett index när vi uppdaterar arrayen, $robots = array("gerty", "Wopr", "Skynet"); // Skapar index 0, 1, 2 $robots[] = "HAL 9000"; // Hamnar automatiskt på index 3 Vän av ordning frågar sig säkert nu vad som händer om man försöker lägga in ett värde på ett existerande index? Ja, som kanske väntat så försvinner det gamla värdet och ersätts av det nya, precis som när man tilldelar ett värde till en existerande variabel, $robots = array("gerty", "Wopr", "Skynet"); // Skapar index 0, 1, 2 $robots[1] = "HAL 9000"; // Byter ut Wopr mot HAL 9000 print_r($robots); Array ( [0] => Gerty [1] => HAL 9000 [2] => Skynet ) 26

27 För att plocka bort ett värde från en array används vanligen konstruktionen unset, $robots = array("gerty", "Wopr", "Skynet"); // Skapar index 0, 1, 2 unset($robots[1]); // Plockar bort roboten på index 1 print_r($robots); Array ( [0] => Gerty [2] => Skynet ) Som synes blir det ett "hål" i arrayen på det index som plockas bort. Det här är avsiktligt då det skulle kunna bli knepigt att hålla reda på vad de olika indexen stod för om arrayen automatiskt hela tiden flyttade om alla värden för att täcka upp det som försvinner. Det är också relativt ovanligt att man faktiskt vill indexera om arrayer så att de ligger "i ordning", men skulle behovet uppstå kan vi använda funktionen array_values för det, $robots = array("gerty", "Wopr", "Skynet"); // Skapar index 0, 1, 2 unset($robots[1]); // Plockar bort roboten på index 1 $robots = array_values($robots); // Indexerar om arrayen print_r($robots); Array ( [0] => Gerty [1] => Skynet ) Det är viktigt att komma ihåg att bara för att det "ser ut" som att det är ett hål i arrayen när man tagit bort ett värde så innebär det inte att det faktiskt är det, det är alltså inte så att det finns ett tomt element som ligger och skräpar någonstans som array_values plockar bort. 27

28 Initiera arrayer med egendefinierade index Än så länge har vår array varit automatiskt initierad och haft sina index fint sorterade i numerisk ordning. Även om detta ofta är att föredra då arrayen kan bli smidigare att jobba med är det inget måste; en array kan i princip använda vilka unika värde som helst som sina index. För att initiera en ny array utan att använda automatisk indexering används den något ovanliga operatorn =>, $authors = array( 42 => "Douglas Adams", 2001 => "Arthur C. Clarke"); print_r($authors); Array ( [42] => Douglas Adams [2001] => Arthur C. Clarke ) Åter igen; även om sista indexet ligger på nummer 2001 innebär det inte att det finns en massa tomma värden i arrayen på index som inte är "upptagna", med andra ord finns fortfarande bara två stycken värden i arrayen $authors, 2 print count($authors); Om vi nu skulle återgå till automatisk indexering och be PHP lägga till ytterligare ett element på nästa lediga index, var skulle den hamna då? Inte på index 0, som man kanske skulle kunna tro, $authors[] = "Spindeln Glenn"; print_r($authors); Array ( [42] => Douglas Adams [2001] => Arthur C. Clarke [2002] => Spindeln Glenn ) 28

29 foreach Att index i arrayen inte längre är i en sorterad ordning för med sig ett nytt problem, det är inte längre möjligt att gå igenom arrayen med en for-loop som börjar på 0 och räknar uppåt tills den slår i taket på antal värden i arrayen. Lyckligtvis finns det en utomordentlig smart lösning: konstruktionen foreach. Till skillnad mot mycket annat i PHP är foreach inte en konstruktion baserad på den C-syntax som vanligen brukar ligga till grund. Många andra programspråk baserade på C-syntax saknar antingen helt funktionaliteten eller har valt att implementera den som en speciell variant av for-loopen (exempelvis Javascript, C++ i och med C++0x och Java efter version 5). Med andra ord är de flesta överens om att foreach som företeelse har ett berättigande, men det finns ingen riktig standardiserad syntax för hur den skall se ut. I grund och botten gör den dock samma sak överallt - går igenom något med ett flertal värden, exempelvis en array, och plockar ut dem en efter en, $authors = array( 42 => "Douglas Adams", 2001 => "Arthur C. Clarke" 2002 => "Spindeln Glenn"); foreach($authors as $value) print "$value\n"; Douglas Adams Arthur C. Clarke Spindeln Glenn I exemplet ovan rabblar foreach igenom arrayen $authors med författare (och en spindel med storhetsvansinne) och uppdaterar variabeln $value tills samtliga värden har gåtts igenom. En alternativ och något besynnerlig syntax till foreach i PHP gör att man samtidigt kan uppdatera en andra variabel med indexet för varje värde som plockas ut, enligt följande, foreach($authors as $index => $value) print "$index = $value\n"; 42 = Douglas Adams 2001 = Arthur C. Clarke 2002 = Spindeln Glenn Naturligtvis kan foreach användas även för indexerade arrayer där de olika värdena ligger i ordning. Till skillnad mot vissa andra språk kan foreach inte användas på strängar, men det är möjligt att använda index-syntaxen med klamrar för att skriva ut enstaka tecken, G $name = "Glenn"; print $name[0]; 29

30 Associativa arrayer En associativ array är vad vi brukar kalla arrayer som använder strängar istället för eller tillsammans med siffror som sina index (även om det rent praktiskt egentligen inte gör någon skillnad då en array i PHP internt inte behandlar strängar och siffror som olika när det kommer till index). $acronyms = array( "php" => "PHP Hypertext Preprocessor", "html" => "Hypertext Markup language", "xml" => "Extensible Markup Language"); print "storlek = ". count($acronyms). "\n"; foreach($acronyms as $index => $value) print "<acronym title=\"$value\">$index</acronym>\n"; storlek = 3 <acronym title="php Hypertext Preprocessor">php</acronym> <acronym title="hypertext Markup language">html</acronym> <acronym title="extensible Markup Language">xml</acronym> 30

31 Flerdimensionella arrayer Då ett index i en array fungerar precis som vilken variabel som helst kan den också innehålla en array, vilket innebär att vi får en array som i sin tur innehåller andra arrayer. Nedanstående exempel skapar en array med tre stycken index ("Apple", "Microsoft", "IBM"), som i sin tur innehåller var sin array. För att gå igenom arrayen använder vi en foreach som plockar ut varje index som variabeln $company och varje värde (arrayen) som variabeln $list. För varje lista som plockas ut gör vi en ny foreach på $list och plockar ut värdena i den en efter en. För varje värde som plockas ut uppdaterar vi variabeln $counter med 1, vilket gör att när alla arrayer har gåtts igenom har vi en totalsumma på antal värden, <html> <body> $systems = array( "Apple" => array("a/ux", "MacOS", "OS X"), "Microsoft" => array("xenix", "MS-DOS", "Windows"), "IBM" => array("pc-dos", "4690 OS", "OS/2", "AIX") ); $counter = 0; // Håller reda på antal operativsystem foreach($systems as $company => $list) print "<b>$company</b>"; print "<ul>"; foreach($list as $os) $counter++; print "<li>$os</li>"; print "</ul>"; print "Antal företag: ". count($systems). "<br/>"; print "Antal operativsystem: $counter";?> </body> </html> 31

32 Formulär Ett formulär är i HTML det sättet som vanligast används för att transportera information från användaren till servern. Varje enskilt formulär är ansvarig för att interaktiva HTML-element som textboxar och dropdown-listor skickas till rätt sida, något som definieras via formulärets action-attribut. HTTP GET Det finns två standardmetoder att föra över informationen från ett formulär till servern, GET och POST. Är ingen av de två metoderna i formuläret definierad används GET, vilket är noterbart då vi för det mesta kommer att vilja använda POST. Skillnad mellan GET och POST är att med GET fungerar formuläret ungefär som om användaren hade klickat på en länk på sidan, och eventuella interaktiva fält med information hamnar efter ett frågetecken i URL:en separerade med & (den så kallade querysträngen), <html> <form action="login.php" method="get"> Username: <input type="text" name="username"/> Password: <input type="password" name="password"/> <input type="submit" value="ok"/> <form> </html> Sidan ovan kommer posta formuläret till sidan "login.php" med användarnamn och lösenord som en del av URL:en, alltså kommer det i webbläsaren stå i klartext exempelvis, I det här exemplet är GET uppenbarligen inte rätt väg att gå. Inloggningsuppgifterna kommer inte bara vara synliga för vem som helst som råkar läsa av URL:en utan kommer också hamn i webbläsarens historik. Metoden GET har en fördel dock som alternativet POST inte har; eftersom formuläret blir postat på samma sätt som när man klickar på en länk går en GET-förfrågan att bokmärka, vilket kan vara praktiskt om formuläret exempelvis hanterar en sökfunktion som användaren vill spara resultatet från i sina bokmärken. HTTP POST Genom att ändra formuläret i exemplet ovan till method="post" byter vi överföringsmetod till POST, som till skillnad mot GET alltså inte skickar fälten synbara som en del av URL:en. Fördelen, förutom ovan nämnda med att fälten inte syns i klartext för användaren, är att man också undgår begränsningen på hur lång en URL får lov att vara, vilket gör att riktigt stora formulär med mycket information helt enkelt inte får plats om de skickas som GET. Exakt var gränsen går beror på vad webbservern är inställd på att klara av då ingen begräsning finns specificerad i de dokument som beskriver protokollet HTTP. 32

33 Hantera formulär med PHP Beväpnade med kunskapen om hur ett simpelt HTML-formulär ser ut skall vi nu gå över till den delen som använder inte ser, det som sker bakom kulisserna när hon eller han klickar på knappen som skickar formuläret tillbaka till servern. Den vanligaste och ofta enklaste metoden för att hantera formulär i PHP är att låta dem posta tillbaka till samma sida och där i, innan formuläret skrivs ut igen, kontrollera med hjälp av PHP huruvida anropet är en POST eller inte, och om det är det göra något med det som användaren postade. Oavsett hur användaren anropar den aktuella sidan finns det ett antal fördefinierade så kallade superglobala arrayer i PHP som alltid finns tillgängliga (faktiskt även när PHP körs utanför kontexten av en webbserver). De här arrayerna skiljer sig från egendefinierade arrayer genom att de alltid börjar med _ och skrivs med stora bokstäver, samt alltså går att komma åt överallt oavsett var i PHP-koden vi befinner oss. Två av dessa superglobala arrayer är $_GET och $_POST, som innehåller just GET och POST-data från användaren, om någon sådan finns. Vi kan utnyttja att arrayen $_POST alltid existerar men bara innehåller data om användaren har postat till sidan via ett formulär, och med en enkel if-sats kontrollera huruvida $_POST är tom eller inte. I PHP evalueras en array utan några index som false, vilket gör en if-sats som den här möjlig: if ($_POST) // Sidan har postats med formulärdata... Även om ovanstående fungerar utan problem finns det en och annan som rynkar på näsan åt att låta PHP använda och utvärdera en array som om det vore en boolesk variabel. För dessa personer finns räddningen i konstruktionen empty, som tar en variabel och returnerar true om variabeln av PHP anses vara tom eller sakna värde. Vi får med andra ord negera uttrycket med ett utropstecken och får då ut en if-sats som istället för "om POST" går att utläsa som "om inte POST är tom", if (! empty($_post)) // Sidan har postats med formulärdata... Ett tredje alternativ är att använda en annan superglobal array, $_SERVER, som innehåller massa teknisk information om anropet, bland mycket annat vilken IP det kommer från och naturligtvis vilken metod som användes för att anropa åt sidan, if ($_SERVER["REQUEST_METHOD"] == "POST") // Sidan har postats med formulärdata... (Ett fjärde alternativ, men nu börjar det bli löjligt, är att kontrollera storleken på $_POST, och anse formuläret postat om count returnerar ett tal större än 0. Välj vilken metod du vill! Frihet! Hurra!) 33

34 För att faktiskt fånga upp vad som har postats måste elementen i HTML-dokumentet ha ett nameattribut. De här attributen blir sedan automatiskt index i den superglobala arrayen $_POST. Nedanstående exempel visar en vidareutvecklad version av det tidigare exemplet (notera att methodattributet är satt till POST). De två input-fälten för användarnamn och lösenord har name-attribut som kontrolleras i PHP när det står klart att användaren har postat formuläret. Att Firefox frågar om lösenordet skall sparas för domänen är något som sker automatiskt när en av textboxarna har typen "password" istället för "text". <html> <body> if (! empty($_post)) // Om användaren har postat formuläret... // Jämför det som skrivits in med två fasta värden if ($_POST["username"] == "leonard" && $_POST["password"] == "fraktal") print "Greetings Leonard!"; else print "Invalid username/password :*("; print "<hr/>";?> <form action="login.php" method="post"> Username: <input type="text" name="username"/> Password: <input type="password" name="password"/> <input type="submit" value="ok"/> <form> </body> </html> 34

35 Skriva tillbaka värden Som utvecklare får vi räkna med att användare kommer fylla i våra formulär felaktigt. Ibland medvetet för att testa vad som händer, ibland för att användaren helt enkelt är dum och inte kan läsa instruktionerna. Oavsett anledning är det upp till oss utvecklare att dels ge felmeddelande och dels se till så att formuläret renderar om sig med den informationen som postades. Ett typiskt exempel skulle kunna vara ett formulär för att skapa en ny användare på en e-handelsplats; förutom kundens namn och hemadress skulle formuläret troligen begära att kunden anger en giltig e-postadress, och om han eller hon skulle missa det så måste vi se till att skriva tillbaka adressen i formuläret igen så att kunden inte behöver fylla i den en gång till. Det är egentligen inga uppenbara konstigheter med att skriva tillbaka värden i formulär (valueattributet på textboxar), det luriga ligger i att $_POST-variabeln är tom första gången som sidan renderas vilket gör att vi kan få varningsmeddelanden om vi försöker komma åt index i den som inte finns. En vanlig lösning på detta problem är att skapa separata variabler med standardvärden, vanligen tomma strängar, och sedan modifiera dem med nya värden om formuläret är postat, <html> <body> $ = ""; $name = ""; // Tomma variabler att skriva till formuläret if (! empty($_post)) // Har användaren postat formuläret? $ = $_POST[" "]; // Fyll i variablerna med formulärdatan $name = $_POST["name"];?> // Validera e-postadressen (väldigt förenklat...) if (strpos($ , "@") === false) // Formuläret OK! Gör något här... else print "<span style='color:#f00'>inte en godkänd e-postadress.</span>"; <form action="index.php" method="post"> Namn: <input type="text" name="name" value=" print $name?>" /> E-post: <input type="text" name=" " value=" print $ ?>" /> <input type="submit" value="ok" /> </form> </body> </html> 35

36 Funktionen filter_var Exemplet på föregående sida fungerar men har lite brister. För det första så är valideringen av e- postadressen minst sagt otillräcklig - allt den gör är att kontrollera om det finns i strängen eller inte. Mer alarmerade är att vi också skriver tillbaka formulärdatan exakt så som användaren har skrivit in den - vilket inte är någon fara så länge som användaren inte skriver ">, för det gör att valuevärdet på textboxen stängs för tidigt och lämnar formuläret öppet för så kallade Cross-Site Scripting (XSS), vilket innebär att en elak användare kan lägga in Javascript på sidan, Med ovanstående namn kommer Javascript injiceras i sidan när innehållet i Namn-textboxen skrivs tillbaka. Även om det i just det här fallet inte är hela världen så kan en välplanerad XSS-attack under de rätta omsändigheterna stjäla cookies från användare och ställa till med riktig skada. Lösningen på bägge problemen är att använda funktionen filter_var* som, precis som namnet antyder, filtrerar en variabel. Funktionen kan användas både för att validera en variabel för att säkra att den har ett korrekt värde (som en e-postadress) och för att ändra en variabels värde (som att filtrera bort "farliga" tecken). Funktionen filter_var tar som första argument textsträngen som skall filtreras och som andra argument en inbyggd konstant (som representerar ett heltal) som säger vilket filter som skall användas. Det här är lite lurigt, för filter_var fungerar olika beroende på vilket filter som används. När filter_var används för att validera exempelvis en e-postadress kommer den returnera false om adressen inte är godkänd, annars kommer den returnera - inte true som vi kanske förväntar oss - utan adressen, $test = filter_var("@fail", FILTER_VALIDATE_ )) // $test = false $test = filter_var("ok@yes.com", FILTER_VALIDATE_ )) // $test = "ok@test.com" För att filtrera, eller snarare ersätta, tecken som kan förstöra formulär använder vi istället filterkonstanten FILTER_SANITIZE_SPECIAL_CHARS som returnerar strängen med eventuella "farliga" tecken omskrivna till sina representationer i "HTML-enteties", så < blir < och " blir &quote;. Det gör att texten kan skrivas tillbaka till formuläret korrekt utan att formuläret går sönder. Alltså kan vi säkra formuläret på förra sidan genom att göra följande ändringar,... // Filtrera bort skadliga tecken $ = filter_var($_post[" "], FILTER_SANITIZE_SPECIAL_CHARS); $name = filter_var($_post["name"], FILTER_SANITIZE_SPECIAL_CHARS); // Validera e-postadressen (korrekt den här gången) if (filter_var($ , FILTER_VALIDATE_ ) === false) * Funktionen filter_var är relativt ny i PHP (från och med PHP 5.2), sitter man på en äldre version kan funktionen htmlspecialchars istället användas för att filtrera formulärdata innan den skrivs tillbaka. 36