Hur man kommer igång med PHP – En handledning för nybörjare
PHP är ett av de vanligaste programmeringsspråken för serverprogrammering. Med tiden har det blivit en integrerad del av moderna webbplatser och internetteknik. Det kan dock vara svårt för nybörjare att lära sig PHP. I denna PHP-handledning visar vi dig grunderna i det populära programmeringsspråket och dess viktigaste operatorer, loopar och funktioner.
Vad du behöver ha innan du börjar PHP-handledningen
Vår handledning riktar sig främst till nybörjare. Det kan dock vara bra att ha grundläggande kunskaper om modern webbutveckling och HTML. För att kunna följa med och reproducera exemplen på din egen dator bör du se till att du har följande förberett:
- Webbserver inklusive PHP-tolken
- PHP installerat
- Webbläsare
- Textredigerare
Som server rekommenderar vi den lokala testmiljön XAMPP, som Apache Friends tillhandahåller kostnadsfritt för operativsystemen Windows, Linux och macOS. XAMPP är en renodlad testserver. Webbutvecklare kan använda programvaran för att enkelt skapa testmiljöer för skript, HTML-sidor och stilmallar. En säker drift av webbservern på internet kan dock inte garanteras. Detaljerade installationsinstruktioner finns i vår XAMPP-handledning.
Vad är syntaxen för PHP?
När du har konfigurerat din lokala webbserver (till exempel med XAMPP) är det en bra idé att testa att PHP har installerats korrekt och är redo att köra skript. Ett skript är ett program som inte är kompilerat till binär kod. Istället körs de av en tolk. Öppna din favorittextredigerare och använd följande PHP-skript:
<?php
phpinfo();
?>
PHP-skript följer en specifik struktur. Den inledande PHP-taggen <?php initieraren skriptmiljö*. Därefter följer den faktiska PHP-koden i form av satser. I exemplet ovan är detta anropet tillfunktionenphpinfo*(). De flesta PHP-funktioner kräver en eller flera parametrar, som omges av parenteser. Förphpinfo () är dessa parametrar valfria:phpinfo(INFO_ALL). Varje sats avslutas med ett semikolon (;). För att avsluta skriptet använder du den avslutande PHP-taggen:?>.
Funktioner är subrutiner som gör det möjligt att outsourca delar av programkoden. För att undvika upprepningar kan återkommande uppgifter definieras en gång som en funktion och sedan anropas med hjälp av ett funktionsnamn. Webbutvecklare använder fördefinierade PHP-funktioner för detta ändamål eller skapar egna subrutiner.
Spara textfilen under namnet test i formatet .php (PHP-skript) och starta din webbserver. Om du använder testmiljön XAMPP sparar du test.php i XAMPP-katalogen under htdocs (C:\xampp\htdocs).
Du kan komma åt exempelfilen via följande URL i webbläsaren: http://localhost/test.php. Om du använder en alternativ webbserver eller en individuell konfiguration av XAMPP-programvaran, välj URL:en enligt respektive filväg.
När du anger URL http://localhost/test.php uppmanar du webbläsaren att begära filen test.php från webbservern. Apache HTTP-servern (eller vilken typ av webbserverprogramvara du än använder) hämtar filen i rätt katalog. Filändelsen .php betyder att filen innehåller PHP-kod. Vid denna punkt aktiveras PHP-tolken som är integrerad i webbservern. Den bearbetar dokumentet och stöter på den inledande PHP-taggen <?php, som signalerar att PHP-koden ska startas. Tolken fortsätter med att exekvera PHP-koden och genererar HTML-utdata som webbservern överför till webbläsaren för visning. Om PHP har installerats korrekt kommer exekveringen av skriptet att resultera i följande webbsida:
Funktionen phpinfo() är en förkortning för standardfunktionen phpinfo( INFO_ALL ). Denna funktion visar detaljerad information om PHP-konfigurationen på din webbserver. Om ingen PHP-version kan hittas visar webbläsaren ett felmeddelande eller levererar PHP-koden till webbläsaren utan att tolka den.
”Hello World!” – Hur man skriver ut text med echo
När du har installerat PHP är det dags att skriva ditt första skript. Du kan använda PHP echo för att göra detta. Till skillnad från phpinfo() är echo inte en funktion. Det är snarare en språkkontruktion som gör det möjligt att skriva ut en efterföljande sträng som text.
Språkkontruktioner är satser som används i PHP för att styra programflödet. Förutom echo finns det språkkontruktioner som if, for, do, include, return, exit eller the. Till skillnad från funktioner behövs inga parenteser.
För ditt första anpassade skript skapar du en ny PHP-fil och anger följande kod:
<?php
echo 'Hello World!';
?>Öppningstaggen <?php startar en skriptmiljö. Den följs av språkkontruktionen echo och strängen Hello World!, som är omgiven av enkla citattecken. Använd taggen ?> för att avsluta skriptet. Observera semikolonet efter satsen. Vilken text som helst kan användas istället för Hello World!.
Spara skriptet som hello.php i katalogen htdocs på din webbserver. Öppna sedan filen med URL http://localhost/hello.php i din webbläsare. Om koden har överförts korrekt ska webbläsarfönstret visa den sträng du använde:
All text som du genererar med echo kan innehålla HTML-taggar efter behov. Dessa taggar tolkas av webbläsaren i enlighet med HTML-specifikationerna. Testa detta koncept med hjälp av följande skript, till exempel:
<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>När det anropas i webbläsaren visas resultatet av skriptets körning enligt följande.
Texten Hello World!, som är innesluten i <h1> taggar, tolkas av webbläsaren som en primär rubrik. Detta följs av ett automatiskt radbrytning och textstycket mellan <p>-taggarna.
Beroende på dina behov kan du använda echo med antingen enkla citattecken (’) eller dubbla citattecken (“). Om du bara skriver ut text spelar valet av citattecken ingen roll. Denna skillnad blir dock betydelsefull när du hanterar PHP-variabler.
Variabler
Echo-språkkontruktionen erbjuder mer än bara textvisning. Textpresentation kan redan utföras effektivt med hjälp av HTML. Den verkliga fördelen med att använda PHP-språkkontruktionen echo ligger i dess förmåga att dynamiskt producera text med hjälp av variabler.
PHP-användare stöter ofta på variabler i följande format: $example
Varje variabel består av ett dollartecken ($) följt av variabelnamnet. Variabler används i PHP-skript för att införliva extern data i webbsidor. De kan omfatta olika typer av värden, från grundläggande siffror och strängar till kompletta texter eller HTML-dokumentstrukturer. PHP skiljer mellan sju olika variabla typer:
| Variabeltyp | Beskrivning |
|---|---|
| Sträng | En sträng är en sekvens av tecken. Den kan representera ett ord, en fras, en textbit eller till och med hela HTML-koden för en webbsida. |
| Heltal | Ett heltal är ett heltal utan decimaler. Det kan vara positivt eller negativt. |
| Flyttal | Ett flyttal är ett tal med flyttal. Det är ett numeriskt värde med decimaler. PHP stöder upp till 14 siffror efter decimaltecknet. |
| Boolesk | Booleska variabler är resultatet av en logisk operation och har endast två värden: TRUE (sant) och FALSE (falskt). Denna typ av variabel används när man arbetar med villkor. |
| Array | En array är en variabel som kan innehålla flera element. Det är en gruppering av flera liknande strukturerade data som har kombinerats till en array. |
| Objekt | Variabeltypen objekt gör det möjligt för programmerare att definiera sina egna datatyper. Den används i objektorienterad programmering. Vi har inkluderat objektvariabler i denna PHP-handledning. |
| NULL | Värdet NULL representerar en variabel utan värde. För variabler av denna typ är NULL det enda möjliga värdet. |
Centralisering av innehåll hanteras vanligtvis via databassystem. Variabla värden kan dock också tilldelas direkt i skriptet. Denna typ av tilldelning använder följande mönster:
$example = "value";Dollartecknet följs av variabelnamnet (i detta fall example). Det är kopplat till ett värde inom dubbla citattecken med hjälp av likhetstecknet (=). Variabelvärden av typen heltal och flyttal skrivs utan citattecken (till exempel $example = 24;och $example= 2.7;).
PHP erbjuder flexibilitet när det gäller att namnge variabler. Vissa begränsningar gäller dock:
- Varje variabel börjar med ett dollartecken.
- Ett variabelnamn är en sträng av bokstäver, siffror och understreck (till exempel $example_1).
- Ett giltigt variabelnamn börjar alltid med en bokstav eller ett understreck ($example1 eller $_example), aldrig med en siffra (fel: $1example).
- PHP är skiftlägeskänsligt. Skriptspråket skiljer mellan stora och små bokstäver ($example ≠ $Example).
- Variabelnamnet får inte innehålla mellanslag eller radbrytningar (fel: $example 1).
- Strängar som är reserverade av PHP för andra ändamål kan inte användas som användardefinierade variabler (t.ex.$this).
Låt oss illustrera detta med ett exempel:
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
?>Den inledande PHP-taggen följs av definitionen av variabeln. I detta fall tilldelas $author värdet John Doe. Vid skriptexekvering ersätts varje förekomst av variabeln $author i skriptet med värdet John Doe i skriptmiljön. En visuell representation av denna process i webbläsaren illustreras i följande diagram:
Om webbsidan ska tillskrivas Max Mustermann, John Does tyska kollega, och inte John Doe, kan du åtgärda detta genom att ändra variabeln $author.
Detta är särskilt effektivt om en variabel förekommer flera gånger i ett skript. I detta fall behöver korrigeringen endast göras på ett enda ställe, nämligen där variabelns värde definieras.
Detta illustrerar PHP:s förmåga: innehåll kan bäddas in med hjälp av variabler. Denna egenskap utgör grunden för dynamisk webbutveckling. Till skillnad från statiska webbsidor, som finns som förrenderade HTML-sidor, genereras dynamiska webbsidor först när sidan öppnas. PHP-tolken hämtar olika element från den begärda webbsidan från olika databaser via variabler och sammanställer dem till en skräddarsydd HTML-sida som överensstämmer med den specifika begäran.
Fördelarna med detta tillvägagångssätt är uppenbara. När delar av webbplatsen (t.ex. i sidfoten) ändras behöver man inte göra manuella justeringar på varje enskild undersida. Det räcker med att uppdatera motsvarande post i databasen. Som ett resultat tillämpas ändringarna automatiskt på alla webbsidor som innehåller relevanta data som variabler. Om en variabel definieras flera gånger i ett skript, ersätter den nya definitionen den tidigare. En efterföljande echo-kommando visar alltid det aktuella värdet för en variabel.
<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";
?>
I kodexemplet tilldelades variabeln $author först värdet John Doe och ersattes sedan med värdet Max Mustermann.
Nu över till ämnet citattecken. Till skillnad från strängar behöver enskilda variabler inte omges av citattecken:
<?php
$author = "John Doe";
echo $author;
?>Förutom när variabeln behöver användas inom en sträng. I detta fall använder du dubbla citattecken (“). Detta instruerar PHP-tolken att söka igenom strängen efter variabler och ersätta dem med motsvarande värden efter behov. Strängar som omges av enkla citattecken (’) tolkas och återges som vanlig textinformation, även när de innehåller variabler.
<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';
?>
Du undrar kanske vad som händer om du utelämnar citattecknen helt och hållet. I så fall pekar PHP på ett syntaktiskt fel.
Felmeddelanden och maskering
Om syntaktiska fel uppstår finns det ingen giltig PHP-kod och PHP-tolken ger ett felmeddelande. Detta kan till exempel förväntas om du använder echo-satsen med en sträng utan citattecken:
<?php
echo Hello World!;
?>Felmeddelanden innehåller i de flesta fall information om var ett fel har uppstått, vilket ger viktig information om hur man kan åtgärda det.
I det aktuella exemplet misstänks ett fel i rad 2 i vår programkod. Det är precis där vi utelämnade citattecknen.
Syntaxfel uppstår också när du vill skriva ut tecken som är associerade med en specifik uppgift i PHP. Ett exempel på detta är citattecknet (’). Tecken som detta kan endast skrivas ut som text i PHP om du anger för tolken att tecknets inneboende funktion har neutraliserats. När det gäller enkla citattecken finns det två sätt att göra detta. Du kan omge en sträng med enkla citattecken med dubbla citattecken, eller så kan du maskera citattecknen med en föregående bakåtslag (\):
<?php
echo '\'Hello World!\' ';
?>
Att kombinera enkla och dubbla citattecken är också en bra metod:
<?php
echo " 'Hello World!' ";
?>Men inte denna stavning:
<?php
echo ' 'Hello World!' ';
?>Mellanslagen mellan citattecknen har införts i exemplen för att underlätta läsbarheten.
Konkateneringsoperatorer
För att mata ut flera variabler samtidigt i ett PHP-skript kan du använda det du har lärt dig hittills och göra följande:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";
?>Skriv bara in båda variablerna i den dubbla citattecknen tillsammans med resten av texten som ska skrivas ut. PHP känner automatiskt igen variablerna genom dollartecknet ($) och infogar rätt värden.
Bland programmerare anses dock denna procedur vara otillbörlig. Det finns en programmeringsregel som säger att variabler inte ska ingå i strängen. En anledning till detta är att många programmeringsspråk kräver denna separering. Ännu viktigare är att PHP också kräver att du separerar strängar och variabler när du arbetar med funktionsanrop eller mer komplexa variabler. På grund av detta är det bäst att hålla dem separerade även i vanlig textutmatning, även om det inte är absolut nödvändigt i detta fall.
När du arbetar med variabler måste du alltid hantera flera element som måste sammanfogas under utmatningen. I PHP används sammanfogningsoperatorn (.) för detta ändamål. Om den programmeras “rent” bör koden för ovanstående exempel se ut så här:
<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
?>
Här har vi tre strängar och två variabler som har sammanfogats till en sträng.
| Sträng1 | Variabel1 | Sträng2 | Variabel2 | Sträng3 | ||||
|---|---|---|---|---|---|---|---|---|
| ’<h1>Hello World!</h1> <p>Denna dynamiska webbsida skapades av ’ | . | $author1 | . | ’ och ’ | . | $author2 | . | ’.</p>’ |
Det är viktigt att nämna att en sammanfogningsoperator sammanfogar strängar eller variabler utan att infoga mellanslag. Om ett mellanslag är avsett måste det uttryckligen inkluderas inom citattecknen i strängen, som visas i exemplet.
Programmerare använder sammanfogningsoperatorn inte bara för att kombinera strängar och variabler för textutmatning, utan också för att utöka variabler. Följande exempel illustrerar hur detta görs:
<?php
$example = 'Hello ';
$ example .= 'World';
echo $ example;
?>För att utöka värdet på en variabel definierar du den igen, men placerar sammanfogningsoperatorn punkt (.) före likhetstecknet. Detta är den vanliga förkortningen för $example = $example . ‘world’.
PHP lägger till det nya värdet till det tidigare definierade. Om du vill ha ett mellanslag mellan de två värdena skriver du det i slutet av den första strängen, som i exemplet.
Bädda in PHP i HTML
I princip är PHP-tolken endast intresserad av kod som finns mellan en öppnande och en stängande PHP-tagg:
<?php [This section is parsed by the PHP interpreter] ?>
Tolken ignorerar alla återstående delar av dokumentet och vidarebefordrar dem till webbservern utan att ändra dem. Som ett resultat kan PHP-kod smidigt införlivas i HTML-dokument efter behov, till exempel när man skapar mallar för innehållshanteringssystem. Det är viktigt att spara HTML-dokument som innehåller PHP-kod med filändelsen PHP. Annars kommer dokumentet att visas direkt i webbläsaren utan att förbehandlas av PHP-tolken. Detta skulle leda till att koden visas som text på webbplatsen.
Du kan tänka på PHP-tolken som webbserverns lata kollega, som bara arbetar när den uttryckligen ombeds att göra det, t.ex. genom en öppnande PHP-tagg.
För att kombinera HTML och PHP skriver du din HTML-sida i den klassiska dokumentstrukturen och sparar den med filändelsen .php:
<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
</body>
</html>Lägg nu till ett PHP-skript i ditt HTML-dokument. Se till att all kod finns inom PHP-taggarna.
<html lang="de">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
</body>
</html>I det här fallet har vi kombinerat språkkontruktionen echo med PHP-funktionen date() för att visa aktuellt datum och tid som servertext. Funktionens parameter anger önskat format, angivet som en sträng:
d.m.Y H:i:s = dag.månad.år timme:minut:sekund.
När en webbläsare begär en sådan fil kör PHP-tolken först skriptet och bäddar in aktuell tid som text i HTML-dokumentet. Därefter överför webbservern detta dokument, som sedan visas i webbläsaren som en webbsida.
PHP-kommentarfunktion
Precis som i HTML-kod kan du också lägga in kommentarer i din PHP-kod. Kommentarer i källkoden ignoreras av PHP-tolken så länge de följer syntaxreglerna. PHP erbjuder tre olika metoder för att lägga in kommentarer.
För att markera en hel rad som kommentar och därmed utesluta den från tolkning kan du antingen använda hashtaggen (#) eller två på varandra följande snedstreck (//). Båda alternativen används i följande kodexempel:
<?php
#This is a single-line comment!
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
//This is also a single-line comment!
?>Textredigeraren Notepad++ markerar kommentarer med grönt. Till skillnad från HTML-kommentarer når textavsnitt som är märkta som kommentarer inom skriptmiljön inte webbläsaren. Denna skillnad uppstår eftersom PHP-tolken redan ignorerar dem under skriptets körning.
Dessutom kan du infoga kommentarer som sträcker sig över flera rader. För att göra detta markerar du början på en kommentarsektion med ett snedstreck följt av en asterisk (/*) och slutet med en asterisk följt av ett snedstreck (*/).
<?php
/*
This is a multiple-line comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>Sådana kommentarer analyseras inte och visas inte på webbplatsen.
Programmerare använder kommentarer för att strukturera källkoden i sina skript, lämna anteckningar för senare redigering eller lägga till intern information till byggnaden, såsom författare eller datum. Kommentarer är valfria och bör användas sparsamt för att säkerställa god läsbarhet av källkoden.
Beräkningar med variabler
I vår PHP-handledning har du redan stött på variabler, främst sådana som innehåller strängvärden. Nu ska vi fördjupa oss i variabler som representerar heltal eller flyttal. När variabler lagrar numeriska värden tillåter PHP att beräkningar utförs med dem. Låt oss börja med att lägga till två heltal:
<?php
$number1 = 237;
$number2 = 148;
$result = $number1 + $number2;
echo "result: " . $result;
?>Först tilldelar vi heltal 237 och 148 till variablerna $number1 och $number2 och definierar sedan variabeln $result. Den används för att lagra summan av variablerna $number1 och $number2. För denna operation använder vi den aritmetiska operatorn +(plus). Slutligen skriver vi ut summan som text med hjälp av språkkontruktionen echo. Observera att du inte behöver använda citattecken när du tilldelar numeriska värden till variabler.
Följande kodexempel visar ett urval av matematiska beräkningar som kan utföras på serversidan med PHP. De PHP-operatorer som används motsvarar till största delen standardmatematiska symboler.
| Aritmetisk operator | Operation | Resultat |
|---|---|---|
| $tal1 + $tal2 | Addition | Summan av $nummer1 och $nummer2 |
| $nummer1 - $nummer2 | Subtraktion | Skillnaden mellan $nummer1 och $nummer2 |
| $nummer1 *$nummer2 | Multiplikation | Produktet av $nummer1 och $nummer2 |
| $nummer1 / $nummer2 | Division | Kvot av $nummer1 och $nummer2 |
| $nummer1 **$nummer2 | Potens | $nummer2-te potens av $nummer1 |
<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; //addition
$subtraction = $number1 - $number2; //subtraction
$multiplication = $number1 * $number2; //multiplication
$division = $number1 / $number2; //division
$power = $number1 ** $number2; //power
?><?php
echo "Result of addition: " . $addition ."<br />";
echo "Result of subtraction: " . $subtraction . "<br />";
echo "Result of multiplication: " . $multiplication . "<br />";
echo "Result of division: " . $division . "<br />";
echo "10 to the 5th power (10^5): " . $power . "<br />";
echo "root of 81: " . sqrt(81) . "<br />";
?>
För komplexa beräkningar kan olika aritmetiska operationer kombineras i ett skript:
<?php
$number1 = 10;
$number2 = 5;
$result = 2 *$number1 + 5* $number2 - 3 * sqrt(81);
echo "Result: " . $result;
?>PHP-tolken bestämmer variablernas värden och beräknar:
2 *10 + 5* 5 - 3 * √81 = 20 + 25 - 27 = 18
Funktionen sqrt() beräknar kvadratroten av parametern inom parentes. Den klassiska operatorrangordningen inom matematiken gäller: punkt före streck. Instruktionen echo visar resultatet som en sträng för webbläsaren.
PHP utvärderar också termer inom parentes först. Den här gången ska vi arbeta med flyttal:
<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 *($number1 + 5)* ($number2 - 3) * sqrt(81);
echo "Result: " . $result;
?>
Liksom alla vanliga programmeringsspråk tillåter PHP operatörer att öka eller minska numeriska värden med värdet 1. Man skiljer mellan pre-inkrementeringsoperatören, pre-dekrementeringsoperatören, post-inkrementeringsoperatören och post-dekrementeringsoperatören.
| Drift | Operatör | Resultat |
|---|---|---|
| Förinkrementering | ++$nummer | Operatorn ++ inkrementerar värdet på variabeln $nummer. Värdet inkrementeras med 1. Resultatet returneras som det nya värdet för $nummer. |
| Förminskning | –$nummer | Operatorn – minskar värdet på variabeln $number. Detta minskar värdet med 1. Resultatet returneras som det nya värdet för $number. |
| Efterinkrementering | $number | Det aktuella värdet för $number returneras först och ökas sedan med 1. |
| Efterminskning | $number– | Det aktuella värdet av $number returneras först och sedan minskas det med värdet 1. |
Först ska vi illustrera hur man utför aritmetiska operationer med inkrementerings- och dekrementeringsoperatorer genom att ge ett exempel med preinkrementering. Följande skript inkrementerar värdet på variabeln $number med 1, lagrar det nya värdet i variabeln $result och skriver sedan ut dess värde som en sträng:
<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;
?>Om du ökar värdet 0 med 1 får du resultatet 1.
För att beräkna förminskningen av variabeln $number använder vi samma skript, men byter ut förökningoperatorn (++) mot förminskningsoperatorn (–):
<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;
?>Här minskar vi värdet 0 för variabeln $number och får resultatet -1.
En ökning före och efter utdata (före vs. efter…) av ett värde kan visas med följande skript:
<?php
$x = 0;
echo '<p>result: ' . ++$x;
echo '<br>x has the value ' . $x;
echo '<p>result: ' . $x++;
echo '<br>x has the value ' . $x, '</p>';
?>I båda fallen får vi samma resultat. Med förinkrementering ökas värdet på x före utmatningen i rad 3, medan det med efterinkrementering ökas efter utmatningen i rad 5.
Hur man använder superglobala variablerna $_GET och $_POST
Du är nu bekant med PHP:s grunder. Du kan arbeta med variabler, sammanfoga och utföra beräkningar. Nästa steg är att illustrera variablernas centrala roll i skriptspråk.
En viktig funktion hos skriptspråk är deras förmåga att utvärdera användarinmatning och överföra värdena till ett annat skript. PHP förlitar sig på superglobala variablerna $_GET och$_POST –fördefinierade systemvariabler som är tillgängligai alla omfattningar – för dataöverföring. Som associativa matriser (datafält) lagrar*$_GET och $_POST* en uppsättning variabler i form av strängar i en variabel.
PHP-matriser kan liknas vid ett skåp med flera lådor. Varje låda har ett utrymme för lagring av data. För att hålla ordning på innehållet i varje låda märker du dem med ett variabelnamn. Beroende på matristyp kan denna identifierare vara ett index eller en nyckel. I indexerade matriser tilldelar du varje låda ett numeriskt index, medan du i associativa matriser märker lådorna med en strängbaserad nyckel.
Superglobals $_GET och $_POST omfattar en samling variabler som representeras som nycklar, vilket möjliggör åtkomst till motsvarande värden. Vi kommer att fördjupa oss i detta när vi utforskar superglobals $_GET och $_POST mer ingående.
Dataöverföring via $_GET
Den superglobala $_GET representerar en array av variabler som skickas till ett PHP-skript med hjälp av en URL.
Om du tillbringar tid på bloggar,ionlinebutiker ochpå internetforum har du kanske lagt märke till några konstiga webbadresser. Vanligtvis är de uppbyggda enligt följande schema:
http://hostname/ordner/filename.php?variablenname=variablevalue
För en blogg kan schemat se ut så här:
http://www.example-blog.com/index.php?id=1
Det är relativt enkelt att bryta ner en sådan URL. På en webbserver som har domänen example-blog.com finns en fil som heter index.php. Denna fil används för att skapa dynamiska webbsidor och innehåller vanligtvis HTML- och PHP-kod, tillsammans med referenser till externa mallfiler och stilmallar – i princip alla komponenter som behövs för att visa webbsidor.
Tillägget id=1 ien URL är ett vanligt sätt att avgöra om en webbsida är dynamisk. Du hittar detta efter frågetecknet (?) i en URL. Denna komponent kallas HTTP-frå gesträng och innehåller en variabel (id) och ett värde (1), som är länkade med ett likhetstecken (=). URL-parametrar av detta slag används för att generera dynamiska webbsidor, hämta databasinnehåll och aktivera lämpliga mallar.
Dynamiska webbplatser möjliggör separering av innehåll och presentation. Även om index.php innehåller information om en webbplats struktur måste den fortfarande fyllas med innehåll. Detta lagras vanligtvis i en databas och kan nås med hjälp av parametrar i HTTP-frågesträngen. I exemplet skickar URL:en till index.php parametern id=1. Detta anger vilket innehåll som ska läsas från databasen och laddas in i index.php. I en blogg kan det vara ID-numret för en artikel, i ett forum ett visst inlägg. I en webbutik kan det vara en specifik produkt.
Om en URL innehåller mer än en parameter, kopplas dessa samman med ett ampersand-tecken (&).
www.example-blog.com/index.php?page=article&id=1
Nedan visar vi hur du använder $_GET. I det här exemplet behöver du inte använda någon databas. I följande skript använder vi superglobala $_GET för att läsa värdena för variablernafirstname och lastname från en HTTP-frågesträng och skriva dem till PHP-variablerna $variable1 och $variable2:
<?php
$variable1 = $_GET['firstname'];
$variable2 = $_GET['lastname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
?>Skriptet anropas via följande URL:
localhost/hello.php?firstname=John&lastname=Doe.
Parametrarnafirstname=John och lastname=Doe har överförts. Värdena visas precis som tidigare med hjälp av språkkontruktionen echo.
En dataöverföring via $_GET leder oundvikligen till att den överförda datan syns i adressfältet. Detta innebär att parametrar som har överförts kan spåras. Fördelen är att variabler kan lagras i hyperlänkar. Dessutom har användarna möjlighet att spara URL:er inklusive HTTP-frågesträngen som bokmärken i sin webbläsare.
Det faktum att GET-parametrarna listas i klartext i URL:en gör dock denna metod oförenlig med överföring av känslig data, såsom data som genereras av onlineformulär. Dessutom begränsas mängden data som kan överföras med $_GET av URL:ens maximala längd.
Du kan kringgå dessa begränsningar med HTTP-metoden POST. Data som överförs med denna metod finns i superglobala variabeln $_POST.
Dataöverföring via $_POST
Medan data i GET-metoden skickas som en URL-parameter, sker dataöverföringen med $_POST i kroppen av en HTTP-begäran. Detta gör det möjligt att även skicka stora mängder data från ett skript till ett annat.
Ett centralt användningsområde för HTTP POST-metoden är överföring av HTML-formulärdata. Vi kommer att demonstrera detta med hjälp av exemplet med prenumeration på nyhetsbrev.
För att göra detta skapar du en ny PHP-fil med namnet page1.php och kopierar följande kodblock:
<form method="post" action="page2.php" >
Please send your newsletter to: <br />
Your name: <input type="text" name="first name" /><br />
Your surname: <input type="text" name="lastname" /><br />
Your email address: <input type="text" name="email" /><br />
<input type="submit" value="Send form" />
</form>HTML-elementet <form> används för att skapa formulär. Starttaggen innehåller två attribut:method och action. Med attributet method definierar du överföringsmetoden, i detta fall HTTP-POST. I attributet action lagrar du URL:en till ett skript som tar emot all data som matas in via efterföljande inmatningsfält. Exemplet visar ett HTML-formulär med tre inmatningselement (input type=“text “) och en skicka-knapp (input type=“submit “). Filen page2.php definieras som mottagare av data.
För att illustrera dataöverföringen med $_POST använder vi ett enkelt skript för att utvärdera formulärdata, som lagrar de inskickade värdena som PHP-variabler och visar dem i textform. För att göra detta skapar du en fil page2.php och infogar följande programkod:
<?php
$name = $_POST["name"];
$surname = $_POST["lastname"];
$email = $_POST["email"];
echo "Hello " . name . " " . $lastname . ", <br />
You have registered with the following e-mail address:" . $email . ".";
?>Spara de två PHP-filerna i mappen htdocs på din testserver och öppna page1.php från följande URL i din webbläsare: http://localhost/page1.php. Din webbläsare visar nu det interaktiva webbgränssnittet för ditt HTML-formulär.
Ange dina inloggningsuppgifter och tryck på knappen Skicka för att överföra variabler från ett skript till ett annat. När du har bekräftat inmatningarna på page1.php omdirigeras du omedelbart till page2.php. Webbläsarfönstret visar resultatet av skriptets körning baserat på de inmatade uppgifterna.
Användarinmatning som registreras via inmatningsfälten på page1.php hämtas av page2.php via:
$_POST["input field name"]
Raden $firstname = $_POST[“firstname”] hämtar inmatningen i inmatningsfältet firstname och lagrar den i variabeln $firstname. Variabeln $firstname kan i sin tur matas ut som en sträng med hjälp av echo.
Hur man använder PHP-jämförelseoperatorer och IF-konstruktionen
Hittills har vi definierat variabler, överfört dem från ett skript till ett annat och matat ut dem som strängar. I nästa steg lär du dig att koppla körningen av kodfragment till vissa villkor.
Språkkontruktionen if låter dig skriva skript på ett sådant sätt att satser endast träder i kraft när ett villkor som du definierar är uppfyllt, till exempel att rätt lösenord anges.
Villkoren definieras i PHP enligt följande grundläggande ramverk:
<?php
if(expression)
{
statement;
}
?>Detta lyder som följer: Om villkoret som beskrivs i uttrycket är uppfyllt kommer satsen att utföras. Ett villkor är alltid uppfyllt om if-konstruktionen returnerar resultatet TRUE (sant). Annars anses det vara FALSE (falskt). I detta fall kommer satsen att hoppas över.
Vanligtvis kontrollerar if-konstruktionen om värdet på en variabel motsvarar det som definierats i villkoret. Denna kontrollstruktur realiseras vanligtvis på basis av jämförelseoperatorer.
Jämförelseoperatorer
Jämförelseoperatorer används för att formulera villkor som sätter två argument i ett logiskt förhållande som kan utvärderas som sant (TRUE) eller falskt (FALSE). När jämförelseoperatorer används i PHP-kontrollstrukturer tillämpas de på två variabler i uttrycket i en if-konstruktion:
if ($a == $b)
{
statement;
}Språkligt sett är kontrollstrukturen följande: om variabeln $a är lika med variabeln $b, så exekveras de satser som definieras i satsen.
PHP:s jämförelseoperatorer baseras på programmeringsspråket C och deras notation skiljer sig avsevärt från klassiska matematiska symboler. En översikt finns i tabellen nedan.
| Jämförelseoperator | Beskrivning | Villkor |
|---|---|---|
| == | lika | Villkoret är uppfyllt om $a och $b har samma värde. |
| === | är identisk | Villkoret är uppfyllt om $a och $b har samma värde och tillhör samma datatyp. Detta kan illustreras med ett exempel där ett heltal (1) jämförs med en sträng (“1”): 1 == “1” //SANT 1 === “1” //FALSKT För villkor som kräver att två variabler är lika är det bäst att alltid använda relationsoperatorn === (är identisk). |
| != | är ojämlik | Villkoret är uppfyllt om $a och $b har olika värden. |
| ! | inte identiska | Villkoret är uppfyllt om $a och $b har olika värden eller tillhör olika datatyper. |
| `< * | är mindre än | Villkoret är uppfyllt om värdet* $a är mindre än värdet $b*. |
| *>` | är större än | Villkoret är uppfyllt om värdet på* $a är större än värdet på $b*. |
| <= | är mindre än eller lika med | Villkoret är uppfyllt om värdet på $a är mindre än värdet på $b eller om $a och $b har samma värde. |
| >= | är större än eller lika med | Villkoret är uppfyllt om värdet på $a är större än värdet på $b eller om $a och $b har samma värde. |
Följande skript bör förtydliga denna kontrollstruktur. Två heltal jämförs. Jämförelseoperatorn < (är mindre) används:
<?php
$number1 = 10;
$number2 = 20;
if($number1 < $number2) {
echo "The condition is fulfilled";
}Vi definierar variablerna $number1 och $number2 och tilldelar dem värdena10 och 20. Därefter ställer vi in ett villkor: om $number1 är mindre än $number2 ska strängen som anges i echo-satsen skrivas ut.
Resultatet av skriptets körning innehåller svaret: 10 är mindre än 20. If-konstruktionen returnerar resultatet TRUE. Villkoret är uppfyllt.
För att definiera satser som exekveras om ett villkor inte är uppfyllt, lägg till språkkontruktionen else till if-satsen för att bilda en if-else-sats i PHP:
<?php
if(condition a)
{
statement b;
}
else
{
statement c
}
?>Detta skript kontrollerar om villkor a returnerar TRUE eller FALSE. Om villkor a är uppfyllt (TRUE) exekveras sats b. Om villkor a inte är uppfyllt (FALSE) hoppas sats b över och sats c exekveras istället.
Låt oss utöka vårt skript med else-konstruktionen och byta ut jämförelseoperatorn < (är mindre än) mot == (är lika med):
<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2)
{
echo "The condition is fulfilled";
}
else
{
echo "The condition is not fulfilled";
}
?>Denna gång returnerar if-konstruktionen FALSE. Värdet på variabeln $number1 är inte lika med värdet på $number2. Villkoret är inte uppfyllt. Därför exekveras inte satsen som anges under if, utan den som definieras under else.
För att koppla utförandet av ett kodfragment till två lika värden används ett dubbelt likhetstecken (==) i PHP. Ett enkelt likhetstecken (=) används för att tilldela värden till variabler.
Du kan negera villkor genom att sätta ett utropstecken (!) före ett uttryck.
<?php
$number1 = 10;
$number2 = 20;
if ($number1 == $number2)
{
echo "The numbers are the same.";
}
if (!($number1 == $number2))
{
echo "The numbers are not equal.";
}
?>Detta exempel belyser villkoret $number1 == $number2 och dess negation. !($number1 == $number2) är likvärdigt med ($number1 != $number2).
En praktisk tillämpning avifandelse är lösenordsfrågan baserad på ett HTML-formulär. Vi kan simulera detta med hjälp av våra PHP-filer page1.php ochpage2.php.
Öppna sidan1.php och klistra in följande kod:
<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="send" />
</form>Strukturen motsvarar ett tidigare skapat formulär. Denna gång räcker det dock med ett enda inmatningsfält: lösenordsfrågan. Precis som tidigare skickas användarens inmatning till skriptet page2.php.
Vi kan anpassa detta med hjälp av följande kod så att lösenordsinmatningen jämförs med ett lagrat lösenord:
<?php
$password = $_POST["password"];
if($password=="qwertz123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}
?>Koden kan förklaras på följande sätt: inledningsvis tilldelar vi variabeln $password ett värde på rad 2, som vi hämtar med hjälp av HTTP POST-metoden. Sedan definierar vi följande kontrollstruktur: if-konstruktionen i rad 3 ska kontrollera om värdet på variabeln $password matchar strängen qwertz123. Om så är fallet visas strängen Lösenordet var korrekt. Om if returnerar resultatet FALSE används else i rad 7 och strängen Lösenordet var felaktigt visas.
Nu anropar vi skriptet page1.php via URL:en http://localhost/page1.php.
Webbläsaren visar webbvyn av vårt HTML-formulär för lösenordsbegäran. Vi anger lösenordet quertz123 som definierats i skriptet page2.php och klickar sedan på knappen Skicka.
Webbläsaren omdirigerar oss automatiskt till page2.php medan if-kontrollstrukturen jämför vår inmatning med det lagrade lösenordet. Resultatet blir*”qwertz123 == qwertz123* är *SANT”*och sedan visas strängen Lösenordet var korrekt.
Testa själv för att se vad som händer när du skriver in ett annat lösenord i inmatningsfältet.
Logiska operatorer
Villkor som du definierar med hjälp av jämförelseoperatorer i uttrycket i if-konstruktionen kan vid behov kombineras med andra villkor i samma uttryck. PHP använder de logiska operatorernaAND och OR.
| Stark koppling | Svagt band | Beskrivning | ||
|---|---|---|---|---|
| && | OCH | Båda villkoren som är kopplade till operatorn måste vara SANT. | ||
| *\ | \ | * | OR | Endast ett av de två villkoren som är kopplade till operatorn måste vara SANT. |
För att kombinera villkor kan du använda tätt bundna och svagt bundna logiska operatorer i PHP. I praktiken ger det ingen märkbar skillnad att använda enbart den ena eller den andra skrivsättet. Om du kombinerar båda skrivsätten kommer du att upptäcka att OR och || är starkare bundna än AND och OR. Dessutom är AND och&& starkare bundna än OR och ||. Detta kan jämföras med rangordningen av operatorer som är känd från matematiska operatorer (t.ex. punkt före streck: *är starkare bundet än+).
Lösenordsfrågan är ett praktiskt exempel. Vanligtvis består inloggningsuppgifterna av ett hemligt lösenord och ett användarnamn. Inloggningen lyckas endast om båda uppgifterna stämmer överens med de uppgifter som finns lagrade i systemet.
Nu öppnar vi vårt lösenordsfrågeformulär igen i Page1.php och lägger till ett inmatningsfält för användarnamnet:
<form action="page2.php" method="post">
Username: <input type="text" name="username" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" value="Submit" />
</shape>I nästa steg måste vi justera kontrollstrukturen för if-konstruktionen. Vi använder den logiska operatorn AND för att länka villkoret för lösenordsfrågan med ett villkor för användarnamnsfrågan.
<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwertz123")
{
echo "Welcome to the internal area" . $username . "!";
}
else
{
echo "Access failed";
}
?>I vårt skript page2.php hämtas värdena förusername och password och sparas i variablerna $username och $password. Uttrycket inom if-konstruktionen innehåller nu två villkor som är kopplade med den logiska operatorn AND. Båda villkoren måste vara uppfyllda (username==“JohnDoe” och $password==“qwertz123”**)för att ifska returneraresultatet TRUE.
När vi hämtar användarnamnet från inmatningsfältet username kan vi använda det direkt i textutmatningen med hjälp av echo-satsen. Welcome to the internal area följs av värdet i $username. Om någon av de två villkoren inte är uppfyllda blir textutmatningen: Access failed.
Logiska operatorer kan kombineras på valfritt sätt. Tänk på att AND har högre prioritet än OR. Precis som i matematiska ekvationer kan du i PHP använda parenteser för att ange prioritet.
Hur man använder loopar (while, for)
Ibland måste ett skript köra igenom en viss del av koden flera gånger innan resten av programkoden exekveras. Programmeringsspråk använder begreppet loopar för detta. Det finns tre typer av loopar i PHP:
- while -slingor
- do-while -slingor
- for -slingor
while -slingor
While-slingan är den enklaste typen av slinga i PHP. Här är den grundläggande strukturen:
while (condition)
{
loop step and other instructions
}While-slingan instruerar PHP att utföra underordnade satser så länge while-villkoret är uppfyllt. För att göra detta kontrollerar PHP-tolken villkoret i början av varje slinggenomgång. Utförandet av den underordnade koden stoppas först när while -villkoret inte längre är uppfyllt.
Denna princip kan illustreras med ett enkelt räkneskript:
<?php
$number = 1;
while ($number <= 10) {
echo $number++ . "<br />";
}
?>Begreppet inkrementering introducerades i avsnittet Beräkningar med variabler i denna handledning. I det följande skriptet bygger vi vidare på detta begrepp, men med en twist. Denna gång använder vi en postinkrementeringsoperator. Detta höjer värdet på heltalvariabeln $number med 1 efter varje iteration av slingan, omedelbart efter echo-textutmatningen. Vi ställer in villkoret för while-slingan enligt följande: $number är större än eller lika med 10. Följaktligen kommer echo-satsen att utföras upprepade gånger tills $number överskrider värdet 10.
Resultatet av skriptets körning är en sträng som skriver ut värdet på variabeln $number för varje loop-pass innan den inkrementeras. Som resultat räknar skriptet från 1 till 10 och slutar köra koden så snart while-villkoret inte längre är uppfyllt.
do-while -slingor
Strukturen för do-while -slingan liknar den för while-slingan. Den enda skillnaden är att villkoret inte kontrolleras i början av varje slingomgång, utan endast i slutet. Det grundläggande schemat för en do-while-slinga är följande:
do {
loop step and other instructions
}
while (condition)Programmerat som en do-while -slinga skulle det föregående skriptet se ut så här:
<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);
?>I det här fallet blir resultatet detsamma. Det som är speciellt med do-while-slingan är att den körs minst en gång, även om villkoret inte uppfylls i något slinggenomgång.
för slingor
Generellt sett har for-slingan i ett PHP-skript samma funktion som while-slingan. Till skillnad från while-slingan skrivs dock startvärdet, villkoret och satsen på en rad istället för att spridas över tre eller flera rader. Den grundläggande strukturen för for-slingan är:
for (start value; condition; loop step)
instructionsExemplet ovan kan skrivas mer kompakt som en for-slinga:
<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}
?>Först definieras värdet 1 för $number. Sedan kontrollerar PHP om villkoret $number <= 1 är uppfyllt. Om så är fallet fortsätter slingan och satserna under slingan exekveras (här är satsen echo). När detta har gjorts exekveras slingans steg. I detta sammanhang blir valet mellan pre- eller postinkrementering irrelevant, eftersom detta steg alltid sker före utmatningen. När slingsteget avslutas inleds nästa iteration av slingan.
I en for- slinga betraktas startvärdet, villkoret och slingsteget som valfria komponenter. I teorin är även tomma slingor möjliga. Sådana slingor skulle dock vara överflödiga.
Det är i princip upp till dig om du skriver dina PHP-skript med en for- eller en while-slinga. Det finns dock ett argument för att välja for-slingor: när for-slingor används får du en bättre överblick över slingans ramverkdata. Detta undviker risken att av misstag skriva en evig slinga som körs tills tolkens minne är fullt. Med hänvisning till föregående exempel kan detta hända när du glömmer att öka värdet på variabeln $number.
Om slingan ska köras minst en gång, oavsett villkor, är dock do-while-slingan den rätta slingan att använda.
breakandcontinue -satser
Exekveringen av en while-, do-while- eller for-slinga kan påverkas avbreak- och continue-satserna. Använd break för att avbryta flödet i en slinga när som helst och fortsätt att hoppa över ett slinggenomgång. Båda satserna är bundna till ett villkor med hjälp av if. Följande exempel visar vårt räkningsskript med ett break:
<?php
for ($number = 1; $number <= 10; $number++) {
if ($number == 5) {
echo "If it is 5, we abort the script!";
break;
}
echo $number . "<br /> ";
}
?>I for-slingan har vi definierat att värdet på variabeln $number ska ökas med värdet 1 i varje slingomgång, med start från 1, tills variabeln har nått värdet 10. Vi kan avbryta denna slinga i förtid med hjälp av break så snart $number har nått värdet 5. Språkkontruktionen echo matar endast ut siffrorna 1 till 4.
För att hoppa över utdata från den femte omgången, men inte stoppa hela slingflödet, ersätter vi break-satsen med continue:
<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "Let's skip the 5!<br />";
continue;
}
echo $number . "<br /> ";
}
?>Istället för siffran 5 visar PHP textsträngen Vi hoppar över nummer 5! som definieras under if.
Hur man utför filoperationer
Dynamiskt webbinnehåll är uppbyggt enligt principen om att separera innehåll och presentation. För att uppnå detta erbjuder skriptspråk som PHP en rad olika funktioner som underlättar sömlös integration av innehåll från externa datakällor i centrala mallfiler. I praktiken är dessa datakällor vanligtvis databaser som hanteras med hjälp av hanteringssystem som MySQL. Du kan läsa mer om hur detta fungerar i vår MySQL-handledning.
Det är också möjligt att inkludera data från filer. Nedan visar vi hur du läser in filer som en sträng i ett PHP-skript och sparar textutdata från ditt skript i filer.
Läsa filer
För att läsa innehållet i en fil har PHP olika funktioner. Av dessa är file() och file_get_contents() särskilt lämpliga för uppgiften. Medan funktionen file_get_contents() läser hela innehållet i en fil till en sträng, sparar funktionen file() innehållet som en array. Varje element i arrayen motsvarar en rad i filen. Med file() blir det enklare att skriva ut varje rad separat.
Vi demonstrerar PHP-filoperationerna på textfilen example.txt, som vi placerar i mappen htdocs på vår testserver. Filen innehåller fyra rader med dummytext:
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.
Först måste vi läsa hela filen som en sträng. För att göra detta måste vi tilldela namnet på motsvarande fil som en parameter till funktionen file_get_contents():
file_get_contents('example.txt')
Nu har vi möjlighet att arbeta med den sträng som har lästs in. Vi kan till exempel tilldela den till en variabel och visa den som text i webbläsaren:
<?php
$example = file_get_contents('example.txt');
echo $example;
?>
I webbläsarens vy kan vi se att textsträngen visas utan stycken. Radbrytningarna i originalfilen syns inte. Det beror på att webbläsaren tolkar skriptets textutdata som HTML-kod. Radbrytningar som definierats i textredigerare går förlorade.
För att behålla den ursprungliga strukturen har du några alternativ. Du kan lägga till HTML-koden för radbrytning (br) i källfilen manuellt med hjälp av sök och ersätt, sätta en <pre> runt filinnehållet, ställa in CSS-egenskapen white-space: pre -wrap eller använda funktionen nl2br() för att signalera till PHP att automatiskt konvertera radbrytningar (nya rader) till HTML-radbrytningar (brytningar). Här är koden:
<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
?>Om ekospråkskonstruktionen används i kombination med nl2br() infogar PHP en HTML-radbrytning före varje ny rad.
För att skriva ut raderna i en fil individuellt kan du använda funktionen file(). Denna läser en fil, numrerar alla rader med start från nummer 0 och sparar deras innehåll som element i en array. Om vi tillämpar detta på vårt exempel får vi följande resultat:
[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit
[1] = Aenean commodo ligula eget dolor. Aenean massa.
[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem
För att visa respektive innehåll med echo anger du bara önskat radnummer. Till exempel visar följande skript endast den första raden i filen example.txt som utdata för webbläsaren:
<?php
$example = file("example.txt");
echo $example [0];
?>
Skriv filer
PHP går utöver att bara läsa filer genom att också låta dig läsa, skapa och ändra filer utan problem.
Användningen av funktionen file_put_contents() är ett utmärkt exempel. Den kräver bara två parametrar: målfilens namn och data, som kan vara en sträng eller en array. I skriptet nedan skapas en ny fil med namnet test.txt, som innehåller strängen This is a test!. Inkluderingen av \r\n säkerställer en radbrytning i filen.
<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt has been created!";
?>
Eftersom file_put_contents inte ger oss någon utdata för webbläsaren lägger vi till ett echo-uttryck som talar om för oss vilken åtgärd som utförs.
Om det redan finns en fil med samma namn i målmappen kommer den att skrivas över. Du kan förhindra detta genom att ställa in parametern FILE_APPEND:
<?php
file_put_contents("test.txt","The test was successful! \r\n", FILE_APPEND);
echo "test.txt has been updated!";
?>Genom att använda file_put_contents() med parametern FILE_APPEND kommer nytt innehåll att läggas till befintligt innehåll.
Det som PHP skriver till målfilen behöver inte nödvändigtvis definieras i skriptet. Alternativt kan du överföra innehåll från en fil till en annan. Följande skript läser innehållet i example.txt och infogar det i filen test.txt:
<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt has been updated!";
?>
