Innan du försöker arbeta med en fil är det en bra idé att se till att den finns. Två funktioner används vanligtvis för att lösa detta problem:

file_exists() och is_file().

Funktionen file_exists() kontrollerar om den givna filen finns. Om filen finns returnerar funktionen TRUE, annars returnerar den FALSE. Syntaxen för funktionen file_exists() är:

bool file_exists(strängfil)

Ett exempel på att kontrollera existensen av en fil:

om (!fil_exists($filnamn)):

print "Filen $filnamn finns inte!";

is_file()

Funktionen is_file() kontrollerar förekomsten av en given fil och förmågan att utföra läs-/skrivoperationer på den. I grund och botten är is_file() en mer robust version av file_exists() som kontrollerar inte bara om en fil finns, utan också om den kan läsa och skriva data:

bool is_file(strängfil)

Följande exempel visar hur man verifierar att en fil finns och att operationer kan utföras på den:

$fil = "någon fil.txt";

if (is_file($fil)):

print "Filen $file är giltig och finns!";

print "Filen $file finns inte eller så är den inte en giltig fil!";

Efter att ha sett till att den önskade filen finns och att du kan utföra olika läs-/skrivoperationer med den, kan du gå vidare till nästa steg - öppna filen.

Filesize()-funktionen returnerar storleken (i byte) på filen med det angivna namnet, eller FALSE vid fel. Syntaxen för funktionen filesize() är:

int filstorlek (sträng filnamn)

Låt oss säga att du vill bestämma storleken på filen pastry.txt. Du kan använda funktionen filesize() för att få den information du behöver:

$fs = filstorlek("pastry.txt"); print "Pastry.txt är $fs bytes.";

Följande resultat visas:

Pastry.txt är 179 byte.

Innan du utför operationer på en fil måste du öppna den och associera den med ett filhandtag, och när du är klar med filen måste du stänga den. Dessa ämnen behandlas i nästa avsnitt.

Öppna och stänga filer

Innan du utför I/O-operationer på en fil måste den öppnas med fopen()-funktionen.

Funktionen fopen() öppnar filen (om den finns) och returnerar ett heltal -- det så kallade filhandtag(filhandtag). Syntaxen för fopen()-funktionen är:

int fopen(strängfil, strängläge[, int include_path])

Filen som öppnas kan finnas på det lokala filsystemet, existera som standardinmatning/utdata eller representera en fil på ett fjärrsystem som accepteras av HTTP eller FTP.

Filparametern kan ha flera former, enligt listan nedan:

Om parametern innehåller namnet på en lokal fil, öppnar funktionen fopen() den filen och returnerar ett handtag.

Om parametern är inställd på php://stdin, php://stdout eller php://stderr, öppnas motsvarande standard input/output-ström.

Om parametern börjar med http://-prefixet, öppnar funktionen en HTTP-anslutning till servern och returnerar ett handtag för den angivna filen.

Om parametern börjar med prefixet ftp:// öppnar funktionen en FTP-anslutning till servern och returnerar ett handtag för den angivna filen. I det här fallet bör du vara särskilt uppmärksam på två saker: om servern inte stöder passivt FTP-läge kommer fopen()-anropet att misslyckas. Dessutom öppnas FTP-filer antingen för att läsa eller skriva.

Vid drift i passivt läge väntar LR-servern på anslutningar från klienter. När du arbetar i aktivt läge upprättar servern själv en anslutning med klienten. Standard är vanligtvis aktivt läge.

Modeparametern avgör om filen kan läsas från eller skrivas till. I tabell. 7.1 listar några värden som bestämmer filöppningsläget.

Tabell 7.1. Filöppningslägen

Läge	Beskrivning
	Bara läsning. Den aktuella positionspekaren är inställd på början av filen
r+	Läser och skriver. Den aktuella positionspekaren är inställd på början av filen
w	Endast spela in. Den aktuella positionspekaren sätts till början av filen och hela innehållet i filen förstörs. Om filen inte finns försöker funktionen skapa den.
w+	Läser och skriver. Den aktuella positionspekaren sätts till början av filen och hela innehållet i filen förstörs. Om filen inte finns försöker funktionen skapa den.
a	Endast spela in. Den aktuella positionspekaren är inställd på slutet av filen. Om filen inte finns försöker funktionen skapa den.
a+	Läser och skriver. Den aktuella positionspekaren är inställd på slutet av filen. Om filen inte finns försöker funktionen skapa den.

Om den valfria tredje parametern include_path är 1, så är filsökvägen relativt till include-katalogen som anges i php.ini-filen (se kapitel 1).

Följande är ett exempel på att öppna en fil med fopen()-funktionen. Die()-anropet, som används i kombination med fopen(), skriver ut ett felmeddelande om filen inte kan öppnas:

$file = "användardata.txt"; // Någon fil

$fh = fopen($fil, "a+") eller die("Fil ($fil) finns inte!");

Följande utdrag öppnar en anslutning till en PHP-webbplats (http://www.php.net):

$site = "http://www.php.net": // Server tillgänglig via HTTP

$sh = fopen($site., "r"); //Associera manipulatorn med Php.nets indexsida

Filen ska alltid stängas med funktionen fclose() efter att den är klar.

Funktionen fclose() stänger en fil med det givna handtaget. Returnerar TRUE vid framgång, FALSE vid misslyckande. Syntaxen för funktionen fclose() är:

int fclose(int manipulator)

Funktionen fclose() stänger framgångsrikt endast de filer som tidigare öppnades av funktionerna fopen() eller fsockopen(). Ett exempel på att stänga en fil:

$file = "användardata.txt";

if (file_exists($file)):

$fh = fopen($fil, "r");

// Utför filoperationer

print "File Sfile existerar inte!";

Skriv till fil

Två grundläggande operationer utförs på öppna filer - läsning och skrivning.

Funktionen is_writeable() verifierar att filen finns och är skrivbar. Skrivbarheten kontrolleras för både fil och katalog. Syntaxen för funktionen is_writeable() är:

bool is_writeable(strängfil)

En viktig faktor: PHP kommer sannolikt att köras under det användar-ID som används av webbservern (vanligtvis "ingen"). Ett exempel på användning av is_writeable() ges i beskrivningen av funktionen fwrite().

Funktionen fwrite() skriver innehållet i en strängvariabel till filen som specificeras av filhandtaget. Syntaxen för funktionen fwrite() är:

int fwrite(int manipulator, strängvariabel [, int längd])

Om en valfri längdparameter skickas när funktionen anropas, stoppas inspelningen antingen efter att det angivna antalet tecken har skrivits eller när slutet av strängen nås. Att kontrollera förmågan att skriva till en fil visas i följande exempel:

// Information om trafik på användarwebbplatsen

$data = "08:13:00|12:37:12|208.247.106.187|Win98";

$filnamn = "någon fil.txt";

// Om filen finns och kan skrivas till

if (is_writeable($filename)):

$fh = fopen($filnamn, "a+");

// Skriv innehållet i $data till en fil

$framgång - fwrite($fh, $data);

// stäng filen

fclose($fh); annan:

print "Kunde inte öppna Sfilename för skrivning";

Funktionen fputs() är ett alias för fwrite() och kan användas var som helst där fwrite() används.

Funktionen fputs() är ett alias för fwrite() och har exakt samma syntax. Syntaxen för funktionen fputs() är:

int fputs(int manipulator, strängvariabel [, int längd])

Personligen föredrar jag att använda fputs(). Tänk på att detta bara är en fråga om stil och inte har något att göra med några skillnader mellan de två funktionerna.

Läser från en fil

Utan tvekan är läsning den viktigaste operationen som utförs på filer. Några av funktionerna som förbättrar effektiviteten av att läsa från en fil beskrivs nedan. Syntaxen för dessa funktioner kopierar nästan exakt syntaxen för liknande inspelningsfunktioner.

Funktionen i s_readable() låter dig se till att filen finns och att en läsoperation är tillåten för den. Läsbarheten kontrolleras för både fil och katalog. Syntaxen för funktionen is_readable() är:

bua! is_readable(strängfil]

Mest troligt kommer PHP att köras under det användar-ID som används av webbservern (vanligtvis "ingen"), så för att funktionen is_readable() ska returnera TRUE måste alla få läsa från filen. Följande exempel visar hur du verifierar att en fil finns och är läsbar:

if (är_läsbar($filnamn)):

// Öppna filen och ställ in den aktuella positionspekaren till slutet av filen

$fh = fopen($filnamn, "r");

print "$filnamn är inte läsbart!";

Funktionen fread() läser det angivna antalet byte från filen som anges av filhandtaget. Syntaxen för funktionen fwrite() är:

int fread(int manipulator, int längd)

Manipulatorn måste referera till en öppen läsbar fil (se beskrivningen av funktionen is_readable()). Läsningen avbryts efter att ha läst det angivna antalet byte eller när slutet av filen nås. Tänk på textfilen pastry.txt som visas i Listing 7.1. Läsning och utmatning av denna fil i webbläsaren görs av följande fragment:

$fh = fopen("pastry.txt", "r") eller die("Kan inte öppna filen!");

$fil = fread($fh, filstorlek($fh));

Genom att använda fllesize()-funktionen för att bestämma storleken på pastry.txt i byte säkerställer du att funktionen fread() läser hela innehållet i filen.

Lista 7.1. Textfil pastry.txt

Recept: Bakelsedeg

1 1/4 koppar universalmjöl

3/4 pinne (6 matskedar) osaltat smör, hackat

2 msk grönsaksfett 1/4 tsk salt

3 matskedar vatten

Funktionen fgetc() returnerar en sträng som innehåller ett tecken från filen vid den aktuella pekarpositionen, eller FALSE om slutet av filen nås. Syntaxen för funktionen fgetc() är:

sträng fgetc (int manipulator)

Manipulatorn måste referera till en öppen läsbar fil (se beskrivningen av funktionen is_readable() tidigare i detta kapitel). Följande exempel visar att läsa och mata ut en fil tecken för tecken med funktionen fgetc():

$fh = fopen("pastry.txt", "r"); medan (!feof($fh)):

$char = fgetc($fh):

tryck $char; endwhile;

Funktionen fgets() returnerar strängen som läses från den aktuella positionen för pekaren i filen som specificeras av filhandtaget. Filpekaren måste peka på en öppen läsbar fil (se beskrivningen av funktionen is_readable() tidigare i det här kapitlet). Syntax för fgets() funktion:

sträng fgets (int manipulator, int längd)

Läsningen avbryts när något av följande villkor är uppfyllt:

läs från fillängd -- 1 byte;
ett nyradstecken lästes från filen (ingår i den returnerade strängen);
end-of-file (EOF) har lästs från filen.

Om du vill organisera rad-för-rad-läsning av filen, skicka in den andra parametern ett värde som uppenbarligen är större än antalet byte i raden. Ett exempel på att läsa och mata ut en fil rad för rad:

$fh = fopen("pastry.txt", "r");

while (!feof($fh));

$line = fgets($fh, 4096);

skriv ut $line. "
";

Funktionen fgetss() är exakt samma som fgets() med ett undantag - den försöker ta bort alla HTML- och PHP-taggar från den lästa texten:

sträng fgetss(Int manipulator, int längd [, sträng tillåtna_taggar])

Innan du går vidare till exemplen, ta en titt på Listing 7.2 -- den här filen används i Listningar 7.3 och 7.4.

Lista 7.2. science.html-filen

Breaking News - Vetenskap

Utomjordisk livsform upptäckt

20 augusti 2000

Tidigt i morse hittades en märklig ny form av svamp växande i garderoben till W. J. Gilmores gamla lägenhetskylskåp. Det är inte känt om kraftfull strålning från hyresgästens datorskärm hjälpte till i denna utveckling.

Lista 7.3. Ta bort taggar från HTML-filen innan de visas i webbläsaren

$fh = fopen("vetenskap.html", "r");

medan (!feof($fh)):

print fgetss($fh, 2048);

Resultatet visas nedan. Som du kan se har alla HTML-taggar tagits bort från filen science.html, vilket resulterar i att formateringen förloras:

I vissa situationer tas alla taggar bort från filen, förutom vissa - till exempel radbrytningstaggar
. Lista 7.4 visar hur detta går till.

Lista 7.4. Selektivt ta bort taggar från en HTML-fil

$fh = fopenC"vetenskap.html", "r");

$allowable="
";

medan (!feof($fh)):

print fgetss($fh. 2048, $tillåtet);

Resultat:

Breaking News - Science Alien livsform upptäcktes den 20 augusti 2000 Tidigt i morse hittades en märklig ny form av svamp växande i garderoben till W. J. Gilmores gamla lägenhetskylskåp. Det är inte känt om kraftfull strålning från hyresgästens datorskärm hjälpte till med detta. Evolution.

Som du kan se gör funktionen fgetss() det enkelt att konvertera filer, speciellt när det finns många HTML-filer formaterad på liknande sätt.

Läsa en fil i en array

File()-funktionen laddar hela innehållet i en fil till en indexerad array. Varje arrayelement motsvarar en rad i filen. Syntaxen för funktionen file() är:

array-fil (strängfil[, int include_path])

Om den valfria tredje parametern include_path är 1, så är filsökvägen relativt till include-katalogen som anges i php.ini-filen (se kapitel 1). Lista 7-5 använder funktionen file() för att ladda filen pastry.txt (se Lista 7-1).

$file_array = fil("pastry.txt");

while (list($line_num. $line) = eacht($file_array)):

skriva ut" Line$line_num:", htmlspecialchars($line), "
\n"

Varje rad i arrayen matas ut tillsammans med ett nummer:

Rad 0: Recept: Konditorivaror

Rad 1: 1 1/4 koppar universalmjöl

Rad 2: 3/4 pinne (6 matskedar) osaltat smör, hackat

Rad 3: 2 matskedar grönsaksfett

Rad 4: 1/4 tsk salt

Rad 5: 3 msk vatten

Omdirigerar en fil till standardutdata

Funktionen readfile() läser innehållet i en fil och skriver den till standardutdata (i de flesta fall till webbläsaren). Syntaxen för funktionen readfile() är:

int readfile(strängfil[, int include_path])

Funktionen returnerar antalet lästa byte. Filen kan finnas på det lokala filsystemet, existera som standard input/output eller representera en fil på ett fjärrsystem som accepteras av HTTP eller FTP. Filparametern ställs in enligt samma regler som i fopen()-funktionen.

Låt oss säga att du har en latorre.txt-fil som du vill visa i webbläsaren:

Restaurang "La Torre." beläget i Nettuno, Italien, erbjuder en eklektisk blandning av stil. historia och fina skaldjursrätter. Inom murarna av den medeltida borgo som omger staden, kan man äta middag medan man ser förbipasserande shoppa i byns butiker. Komfort i kombination med endast de färskaste sjöfarten gör La Torre till en av Italiens finaste restauranger.

När följande kodavsnitt exekveras skickas hela innehållet i latorre.txt till standardutgångsströmmen:

$restaurant_file = "latorre.txt";

// Skicka hela filen till standardutdata

readfile($restaurang_fil);

Öppnar en process filhandtag

Tillsammans med vanliga filer kan du öppna filhandtag för att interagera med processer på servern. Problemet löses av popen()-funktionen, som har följande syntax:

int popen(strängkommando, strängläge)

Kommandoparametern anger systemkommandot som ska utföras, och lägesparametern beskriver åtkomstläget:

// Öppna filen "spices.txt" för att skriva

$fh = fopen("kryddor.txt","w");

// Lägg till flera rader text

fputs($fh, "Persilja, salvia, rosmarin\n");

fputs($fh, "Paprika, salt, peppar\n");

fputs($fh, "Basilika, salvia, ingefära\n");

// Stäng Manipulator

// Öppna en UNIX grep-process för att söka efter ordet Basil i spices.txt

$fh - popen("grep Basil< spices.txt", "r");

// Skriv ut utdata från grep

Resultatet ser ut så här:

Basilika, salvia, ingefära

Funktionen fpassthru() är analog med funktionen passthru() som diskuteras i avsnittet "Köra externa program" i detta kapitel.

När alla åtgärder är klara måste filen eller processen stängas. Funktionen pclose() stänger anslutningen till processen som specificeras av handtaget, liknande hur funktionen fclose() stänger en fil som öppnas av fopen()-funktionen. pclose() funktionssyntax:

int pclose(int manipulator)

I parameter manipulator manipulatorn som erhölls tidigare från ett lyckat popen()-anrop skickas.

Öppna en uttagsanslutning

PHP är inte begränsat till att interagera med filer och processer - du kan också göra socket-anslutningar. uttag(socket) är en mjukvaruabstraktion som låter dig kommunicera med olika tjänster på en annan dator.

Funktionen fsockopen() upprättar en socketanslutning till en server på Internet

via TCP- eller UDP-protokoll. Syntaxen för funktionen fsockopen() är:

int fsockopen (strängnod, int port [, int error_code [, sträng error_text [, int timeout]]])

De valfria parametrarna error_code och error_text innehåller information som kommer att visas om anslutningen till servern misslyckas. Båda parametrarna måste skickas med referens. Den tredje valfria parametern, timeout, anger hur länge man ska vänta på ett svar från servern (i sekunder). Lista 7-6 visar hur man använder funktionen fsockopen() för att få information om en server. Innan vi tittar på Listing 7.6 finns det dock ytterligare en funktion som måste introduceras, socket_set_blocking().

UDP (User Datagram Protocol) är ett kommunikationsprotokoll som inte är anslutningsorienterat.

socket_set_blocking()

Funktionen socket_set_b1ocki ng() låter dig ställa in tidsgränskontroller för serveroperationer:

socket_set_blocking(int manipulator, booleskt läge)

Manipulatorparametern anger det tidigare öppnade uttaget, och lägesparametern väljer det läge som uttaget växlar till (TRUE för blockeringsläge, FALSE för icke-blockerande läge). Ett exempel på användning av funktionerna fsockopen() och socket_set_blocking() visas i Lista 7.6.

Notering 7.6. Använda funktionen fsockopen() för att hämta serverinformation

function getthehost($host.$path) (

// Öppna anslutning till nod

$fp - fsockopen($host, 80, &$errno, &$errstr, 30);

// Växla till blockeringsläge

socket_set_blocking($fp, 1),

// Skicka rubriker

fputs($fp,"GET $path HTTP/1.1\r\n");

fputs($fp, "Värd: $host\r\n\r\n"); $x = 1;

// Få rubriker

medan($x< 10) :

$headers = fgets($fp, 4096);

// Stäng Manipulator

getthehost("www.apress.com", "/");

Lista 7.6 ger följande resultat:

HTTP/1.1 200 OK Server: Microsoft-IIS/4.0 Innehållsplats:

2000 20:25:06 GMT ETag: "f0a61666dbff1bf1:34a5" Innehållslängd: 1311

Funktionen pfsockopen() är en beständig version av fsockopen(). Detta innebär att anslutningen inte automatiskt avslutas när skriptet som funktionen anropades i slutar. Syntax för funktionen pfsockopen():

int pfsockopen (string host, int port [, int error_code [, string error_text [, int timeout]]])

Beroende på de specifika målen för din applikation kan det vara bekvämare att använda pfsockopen() istället för fsockopen().

Starta externa program

PHP-skript kan också köra program som finns på servern. Denna funktion används särskilt ofta när man administrerar systemet via en webbläsare, såväl som för att mer bekvämt få fram sammanfattande information om systemet.

Exec()-funktionen körs givet program och returnerar den sista raden i dess utdata. Syntaxen för exec()-funktionen är:

sträng exec (strängkommando [, strängmatris [, int retur]])

Observera att funktionen exec() endast kör kommandot, inte resultatet av sitt arbete. All kommandoutgång kan lagras i en valfri arrayparameter. Dessutom, om en returvariabel också anges när en arrayparameter anges, tilldelas den senare returkoden för det körda kommandot.

Lista 7.7 visar hur man använder funktionen exec() för att köra UNIX-systemets ping-funktion.

Notering 7.7. Kontrollerar anslutningen till servern med hjälp av exec()-funktionen

exec("ping -c 5 www.php.net", $ping);

// På Windows, exec("ping -n 5 www.php.net. $ping);

för ($i=0; $i< count($ping);$i++) :

skriva ut"
$ping[$i]";

Resultat:

PING www.php.net (208.247.106.187): 56 databyte

64 byte från 208.247.106.187: icmp_seq=0 ttl=243 time=66.602 ms

64 byte från 208.247.106.187: icmp_seq=1 ttl=243 time=55.723 ms

64 byte från 208.247.106.187: icmp_seq=2 ttl=243 time=70.779 ms

64 byte från 208.247.106.187: icmp_seq=3 ttl=243 time=55.339 ms

64 byte från 208.247.106.187: icmp_seq=4 ttl=243 time=69.865 ms

www.php.net pingstatistik --

5 paket överförda. 5 paket mottagna. 0 % paketförlust

tur och retur min/avg/max/stddev - 55.339/63.662/70.779/6.783 ms

Backsticks

Det finns ett annat sätt att utföra systemkommandon som inte kräver anropsfunktioner - det körda kommandot är omgivet av backticks (` `), och resultaten av dess arbete visas i webbläsaren. Exempel:

skriva ut"

$utgång

Detta utdrag skriver ut innehållet i katalogen där skriptet finns till webbläsaren.

Intern parameter ping -c 5 (-p 5 tum Windows-system) anger antalet serverundersökningar.

Om du bara vill returnera råutdata från ett kommando, använd passthru()-funktionen som beskrivs nedan.

Funktionen passthru() fungerar på ungefär samma sätt som exec(), med ett undantag - den matar automatiskt ut resultatet av kommandot. Syntaxen för passthru()-funktionen är:

void passthru(strängkommando [, int return])

Om den valfria returparametern skickas i passthru()-anropet, ställs denna variabel in på returkoden för det körda kommandot.

escapeshellcmd()

Funktionen escapeshellcmd() escapes alla potentiellt farliga tecken som kan skrivas in av användaren (till exempel på HTML-formulär), för att köra kommandona exec(), passthru(), system() eller popen(). Syntax:

string escapeshellcmd (strängkommando)

Användarinmatning bör alltid behandlas med en viss försiktighet, men ändå kan användare ange kommandon som kommer att utföras av systemets kommandokörningsfunktioner. Tänk på följande utdrag:

$user_input = `rm -rf *`; // Ta bort den överordnade katalogen och alla dess underkataloger

exec($user_input); // Kör $user_input !!!

Om inga försiktighetsåtgärder vidtas kommer ett sådant kommando att leda till katastrof. Du kan dock använda escapeshellcmd()-funktionerna för att undvika användarinmatning:

$user_input = `rm - rf *`; // Ta bort den överordnade katalogen och alla dess underkataloger

exec(escapeshellcmd($user_input)); // Fly farliga karaktärer

Funktionen escapeshellcmd() undkommer tecknet * för att förhindra katastrofala konsekvenser av att köra kommandot.

Säkerhet är en av de viktigaste aspekterna av programmering på webben, så jag har ägnat ett helt kapitel åt detta ämne och hur det relaterar till PHP programmering. Se kapitel 16 för mer information.

Arbeta med filsystemet

PHP har funktioner för att visa och utföra olika operationer på filer på servern. Information om serverfilattribut (plats, ägare och privilegier) är ofta användbar.

Funktionen basename() extraherar filnamnet från det angivna fullständiga namnet. Syntaxen för funktionen basename() är:

sträng basnamn(sträng fullständigt_namn)

Att extrahera basfilnamnet från det fullständiga namnet görs på följande sätt:

$path = "/usr/local/phppower/htdocs/index.php"; $fil = basnamn($sökväg); // $fil = "index.php"

Faktum är att den här funktionen tar bort sökvägen från det fullständiga namnet och lämnar bara filnamnet.

Funktionen getlastmod() returnerar det senaste ändringsdatumet och tiden för sidan från vilken funktionen anropas. Syntaxen för funktionen getlastmod() är:

int getlastmod(void)

Det returnerade värdet överensstämmer med UNIX datum/tid-format, och du kan använda date()-funktionen för att formatera det. Följande utdrag skriver ut datumet då sidan senast ändrades:

echo "Senast modifierad: ".date("H:i:s a". getlastmod());

Funktionen stat() returnerar en indexerbar array med detaljerad information om filen med det angivna namnet:

array stat(sträng filnamn)

Följande information returneras i arrayelementen:

0 enhet

2 Indexnodsskyddsläge

3 Antal länkar

4 Ägarens användar-ID

5 Ägargrupp-ID

6 Inode enhetstyp

7 Storlek i byte

8 Tidpunkt för senaste åtkomst

9 Tidpunkt för senaste ändring

10 Senast ändrad tid

11 Blockstorlek för input/output i filsystemet

12 Antal tilldelade block

Således, om du vill veta när filen senast öppnades, titta på element 8 i den returnerade arrayen. Tänk på ett exempel:

$file - "datafile.txt";

list($dev, $inode, $inodep, $nlink, $uid, $gid, $inodev, $size, $atime, $mtime, $ctime,

$bsize) = stat($fil);

print "$filen är $size byte.
";

print "Senaste åtkomsttid: $atime
";

print "Senaste ändringstid: $mtime
";

Resultat:

popen.php är 289 byte.

Sista tillträdestid: 15 augusti 2000 12:00:00

Senaste ändringstid: 15 augusti 2000 10:07:18

I det här exemplet har jag använt list()-konstruktionen för att namnge varje returvärde. Naturligtvis kan du lika gärna returnera en array, gå igenom elementen och visa all information du behöver. Som du kan se låter stat()-funktionen dig få olika användbar information om en fil.

Visa och ändra egenskaperna hos filer

Varje fil på UNIX-familjens system har tre viktiga egenskaper:

tillhöra en grupp;
ägare;
behörigheter.

Alla dessa egenskaper kan ändras med hjälp av lämpliga PHP-funktioner. Funktionerna som beskrivs i det här avsnittet fungerar inte på system i Windows-familjen.

Om du är ny på UNIX-operativsystem kan information om egenskaperna hos UNIX-filsystemet hittas på http://sunsite.auc.dk/linux-newbie/FAQ2.htm. Ämnena gruppägande, ägande och behörigheter behandlas i avsnitt 3.2.6.

Funktionen chgrp() försöker ändra gruppen som den givna filen tillhör. Syntax för chgrp()-funktionen:

int chgrp (sträng filnamn, blandad grupp)

Funktionen filegroup() returnerar grupp-ID:t för ägaren av filen med det angivna namnet, eller FALSE vid fel. Syntaxen för funktionen filegroup() är:

int filgrupp (sträng filnamn)

Funktionen chmod() ändrar behörigheterna för en fil med det angivna namnet. Syntaxen för chmod()-funktionen är:

int chmod (sträng filnamn, int behörigheter)

Behörigheter anges i oktal. Detaljerna för att ställa in parametern för chmod ()-funktionen visas i följande exempel:

chmod("data_fil.txt", g+r); // Fungerar inte

chmod("data_fil.txt", 766); // Fungerar inte

chmod("data_fil.txt", 0766); // Arbetar

Fileperms()-funktionen returnerar behörigheterna för filen med det angivna namnet, eller FALSE vid fel. Syntaxen för funktionen fileperms() är:

int fileperms (sträng filnamn)

Funktionen chown() försöker ändra ägaren till en fil. Rätten att ändra ägare till en fil ges endast till en privilegierad användare. Syntaxen för chown()-funktionen är:

int chown (sträng filnamn, blandad användare)

Funktionen fileowner() returnerar användar-ID för ägaren av filen med det angivna namnet. Syntaxen för funktionen fileowner() är:

int filägare (sträng filnamn)

Kopiera och byta namn på filer

Andra användbara systemfunktioner som PHP-skript kan utföra inkluderar kopiering och byte av filer på servern. Dessa operationer utförs av två funktioner: copy() och rename().

Att kopiera en fil i ett PHP-skript är lika enkelt som att använda UNIX cp-kommandot. Problemet löses av PHPs copy() funktion. Syntaxen för funktionen copy() är:

int copy (strängkälla, strängdestination)

Funktionen copy() försöker kopiera källfilen till målfilen; returnerar TRUE vid framgång, FALSE vid misslyckande. Om målfilen inte finns skapar funktionen copy() den. Följande exempel visar hur man säkerhetskopierar en fil med funktionen copy():

$data_file = "data.txt";

copy($data_file. $data_file".bak") or die("Kunde inte kopiera $data_file");

Funktionen rename() byter namn på en fil. Returnerar TRUE vid framgång, FALSE vid misslyckande. Syntax för rename() funktion:

bool byta namn (sträng gammalt_namn, sträng nytt_namn)

Ett exempel på att byta namn på en fil med funktionen rename():

$data_file = "data.txt";

rename($datafil, $datafile.old") eller die ("Kunde inte byta namn på $datafil");

Ta bort filer

Funktionen unlink() tar bort filen med det angivna namnet. Syntax:

int unlink (strängfil)

Om du arbetar med PHP på ett Windows-system finns det några problem när du använder den här funktionen. I det här fallet kan du använda system()-funktionen som beskrivs ovan och ta bort filen med kommandot DOS del:

system("del filnamn.txt");

Arbeta med kataloger

PHP-funktioner låter dig se innehållet i kataloger och navigera genom dem. Lista 7.8 visar en typisk UNIX-katalogstruktur.

Notering 7.8. Typisk katalogstruktur

Funktionen dirname() kompletterar basename() -- den extraherar sökvägen från det fullständigt kvalificerade filnamnet. Syntax för funktionen dirname():

sträng dirname (sträng sökväg)

Ett exempel på att använda dirname() för att extrahera en sökväg från ett fullständigt kvalificerat namn:

$path = "/usr/locla/phppower/htdocs/index.php";

$fil = dirname($sökväg); // $file = "usr/local/phppower/htdocs"

Funktionen dirname() används ibland tillsammans med variabeln $SCRIPT_FILENAME för att få den fullständiga sökvägen till skriptet från vilket kommandot körs:

$dir - dirname($SCRIPT_FILENAME);

Funktionen is_dir() kontrollerar om filen med det angivna namnet är en katalog:

bool is_dir (sträng filnamn)

Följande exempel använder katalogstrukturen från lista 7.8:

$ isdir = is_dir("index.html"); // Returnerar FALSK

$isdir = is_dir("bok"); // Returnerar TRUE

Funktionen mkdir() gör samma sak som UNIX-kommandot med samma namn - den skapar en ny katalog. Syntaxen för funktionen mkdir() är:

int mkdir (strängsökväg, int-läge)

Parametern sökväg anger sökvägen för att skapa den nya katalogen. Glöm inte att avsluta parametern med namnet på den nya katalogen! Modeparametern bestämmer de behörigheter som tilldelas den skapade katalogen.

Precis som funktionen fopen() öppnar ett handtag för en given fil, öppnar funktionen opendir() ett handtag för en katalog. Syntaxen för funktionen opendir() är:

int opendir (strängsökväg)

Funktionen closedir() stänger kataloghandtaget som skickas som en parameter. Syntax för closedir() funktion:

void closedir(int directory_manipulator)

Funktionen readdir() returnerar nästa element i den givna katalogen. Syntax:

string readdir(int directory_manipulator)

Med den här funktionen kan du enkelt lista alla filer och underkataloger i den aktuella katalogen:

$dh = opendir(" .);

while ($fil = readdir($dh)):

skriv ut "$file
"; under tiden;

Funktionen chdir() fungerar precis som UNIX cd-kommandot, genom att den ändras till den katalog som anges av parametern. Syntax för chdir()-funktionen:

int chdir (strängkatalog)

I följande exempel navigerar vi till boken/underkatalogen och visar dess innehåll:

$newdir = "bok";

chdir($newdir) or die("Kunde inte ändra till katalog ($newdir)"); $dh = opendir(" . ");

while ($fil = readdir($dh));

skriv ut "$file
";

Funktionen rewlnddir() sätter den aktuella positionspekaren till början av katalogen som öppnas av funktionen opendir(). Syntax för rewinddir() funktion:

void rewinddir(int dir_nipulator)

Projekt 1: En enkel träffräknare

Skriptet som presenteras i det här avsnittet räknar antalet träffar för sidan det är på. Innan du går vidare till koden i lista 7-9, granska algoritmen skriven i pseudokod:

Ställ in variabeln $access till namnet på filen som ska lagra räknarvärdet.
Använd funktionen file() för att läsa innehållet i $access i arrayen $visits. Prefixet @ före ett funktionsnamn undertrycker möjliga fel (till exempel frånvaron av en fil med det angivna namnet).
Ställ in variabeln $current_visitors till värdet för det första (och enda) elementet i $visits-matrisen.
Öka värdet på $current_visitors med 1.
Öppna $access-filen för skrivning och ställ in den aktuella positionspekaren till början av filen.
Skriv värdet för $current_visitors till $access-filen.
Stäng manipulatorn med hänvisning till $access-filen.

Notering 7.9. Enkel träffräknare

// Scenario: enkel träffräknare

// Syfte: spara antalet träffar i filen

$access = "hits.txt"; // Filnamnet väljs godtyckligt

$current_visitors = $besök; // Hämta det första (och enda) elementet

++$current_visitors; // Öka antalet träffar

$fh = fopen($access. "w"); // Öppna hits.txt-filen och ställ in

// pekare till den aktuella positionen i början av filen

@fwrite($fh, $current_visitors);// Skriv nytt räknarvärde

// till filen "hits.txt"

fclose($fh); // Stäng filhandtaget "hits.txt"

Projekt 2: bygga en webbplatskarta

Skriptet i Listing 7-10 bygger en webbplatskarta, en hierarkisk representation av alla mappar och filer på servern, med början i en given katalog. Vid beräkning av indragen för de element som utgör webbplatskartan används de funktioner som definierats i detta och tidigare kapitel. Innan du fortsätter till programmet, granska algoritmen skriven i pseudokod:

Deklarera tjänstvariabler för lagring av den överordnade katalogen, namnet på grafikfilen med mappbilden, sidnamnet och flaggan för serverns operativsystem (Windows eller annat system).
Deklarera en display_directory()-funktion som läser innehållet i en katalog och formaterar den för visning i webbläsaren.
Konstruera katalogsökvägen genom att sammanfoga namnet som skickas i variabeln $dir1 med $dir.
Öppna en katalog och läs dess innehåll. Formatera katalog- och filnamn och visa dem i webbläsaren.
Om den aktuella filen är en katalog, anropa display_directory()-funktionen rekursivt och ge den namnet på den nya katalogen som ska visas. Beräkna indraget som används när du formaterar utdata.

Om filen inte är en katalog, formateras den för att visas som en hyperlänk (och indraget som används i formateringen beräknas också).

Notering 7.10. sitemap.php-programmet

// Fil: sitemap.php

// Syfte: bygga en webbplatskarta

// Katalog som du kan börja bygga kartan från

$beg_path = "C:\Program FilesVApache Group\Apache\htdocs\phprecipes";

// Fil med en grafisk bild av mappen.

// Sökväg måste vara relativ* till rotkatalogen på Apache-servern

$folder_location = "C:\Mina dokument\PHP för programmerare\FINAL CHPS\graphics\folder.gif";

// Text i fönstrets titel $page_name = "PHPRecept SiteMap";

// På vilket system kommer skriptet att användas - Linux eller Windows?

// (0 - Windows; 1 - Linux)

$usingjinux = 0;

// Funktion: display_directory

// Syfte: Läs innehållet i katalogen som anges av parametern

// $dir1, följt av formatering av hierarkin av kataloger och filer.

// Funktionen kan kallas rekursivt.

function display_directory ($dir1, $folder_location, $using_linux, $init_depth) (

// Uppdatera sökväg

sdh = opendir($dir);

while($fil = readdir($dh)):

// Delar av kataloger "." och ".." matas inte ut.

if (($fil != ".") && ($fil != "..")) :

if ($using_linux == 0) :

$djup = explode("\\", $dir): annat:

$djup = explode("/", $dir); endif; $curtent_depth = sizeof($depth);

// Bygg sökvägen enligt reglerna för operativsystemet som används. if ($using_linux == 0) :

$tab_depth = $current_deptn - $init_depth;

$fil = $dir. "\\", $fil; annan:

$fil = $dir. "/",$fil; endif;

// Innehåller variabeln $file en katalog? if (är dir($file)):

// Beräkna stoppning

medan ($x< ($tab_depth * 2)) :

$x++; endwhile;

skriva ut"

".basnamn($fil)."
";

// Öka räknaren

// Rekursivt anrop till display_directory()-funktionen

display_directory($file, $folder_location, $using_linux, $init_depth);

// Inte en katalog

// Bygg banan enligt reglerna för den använda

// operativ system.

if ($using_linux == 0) :

$tab_depth = ($current_depth - $init_depth) - 2; $x = 0;

// Beräkna stoppning

medan ($x< (($tab_depth * 2) + 5)) :

skriva ut" ".basnamn($fil)."
";

endif; // Is_dir(fil) endif: // If ! "." eller ".."

// Stäng katalogen closedir($dh);

<? print "$page_name"; ?>

// Beräkna initial utfyllnad

if ($using_linux == 0) :

$djup = explode("\\", $beg_path);

$djup = explode("/", $beg_path);

$init_depth = sizeof($depth);

display_directory($beg_path, $folder_location, $using_linux, $init_depth);

På fig. Figur 7.1 visar utdata från skriptet för en katalog med flera kapitel i den här boken.

Ris. 7.1. Visar katalogstrukturen på servern med skriptet sitemap.php

Resultat

Det här kapitlet har introducerat många av PHP-verktygen för att arbeta med filer. Vi funderade särskilt på följande frågor:

kontrollera förekomsten av filer;
öppna och stänga filer och input/output-strömmar;
skriva till en fil och läsa från den;
omdirigera filen till utdataströmmen;
lansering av externa program;
filsystemoperationer.

Materialet i det här kapitlet lägger grunden för nästa kapitel, Strängar och reguljära uttryck, eftersom strängbearbetning och I/O-operationer är mycket nära besläktade i webbapplikationsutveckling.

Och nu kommer det att bli en ganska stor, men inte komplicerad lektion om att arbeta med filer i php. Först och främst, vad är filerna till för? När allt kommer omkring kan du lagra allt i en MySQL- eller PostgreSQL-databas eller någon annan. Men ibland finns det sådana uppgifter när du använder databasen, med all bearbetning och oro för säkerheten för anslutningen, är inte tillrådligt. Till exempel måste du göra en vanlig räknare, och innan dess använde vi inte en databas i vårt projekt. Så varför skulle vi, för en liten räknares skull, starta en databas och bara lagra ett par rader i den? det är mycket lättare att använda filer. Dessutom, ibland stöder inte hosting databaser alls, då förblir filer i allmänhet den enda utvägen.

Tja, låt oss säga att jag övertygade dig om att filerna behövs :) Låt oss nu ta reda på hur man arbetar med dem. Hur man skapar, öppnar, skriver, skriver över, läser och så vidare. Om allt i ordning.

Skapa en fil

PHP använder fopen-funktionen för att öppna filer. Men det kan också skapa filer. Om du skickar fopen ett filnamn som inte finns kommer det att skapa det.

Själva fopen-funktionen tar två parametrar, som båda krävs. Först måste vi ange namnet på filen vi vill öppna. För det andra, skicka en parameter som talar om för funktionen vad vi planerar att göra med den här filen (till exempel läsa från en fil, skriva och så vidare).

Om du behöver skapa en fil, ange dess namn och skicka parametern som vi vill skriva data till den. Notera: Vi måste se till att PHP får veta att vi skriver till en fil, annars kommer den inte att skapa en ny fil.

Exempel:

$ourFileName = "testFile.txt";

$ourFileHandle = fopen($ourFileName, "w") eller die("kan inte öppna filen");

fclose($ourFileHandle);

Den första raden $ourFileName = testFile.txt skapar en strängvariabel där vi lagrar filnamnet.

Den andra raden $ourFileHandle = fopen($ourFileName, 'w') eller die("kan inte öppna filen") respektive skapar eller öppnar en befintlig fil för skrivning. Annars returnerar den ett meddelande om att den inte kan öppna filen.

Den tredje raden fclose($ourFileHandle) stänger filen. Faktum är att allt är enkelt.

php-filöppningsalternativ

Den första parametern 'r' (läs) - öppnar filen endast för läsning, det kommer inte att vara möjligt att skriva till den.

Den andra parametern är 'w' (skriv) - öppnar för skrivning. I det här fallet kommer inspelningen alltid att gå från början av filen. Om det redan finns information där kommer den att skrivas över.

Den tredje parametern 'a' (lägg till) - öppnar filen för skrivning, men den läggs till i slutet av filen, till skillnad från w.

Avancerade alternativ:

'r+' parameter - öppnar både för läsning och för skrivning. Pekaren kommer att vara i början av filen.

Parameter 'w+' - öppnar både för läsning och skrivning, MEN raderar all information som fanns i filen!!!

parameter 'a+' - öppnar för läsning och skrivning, men pekaren kommer att vara i slutet av filen.

Naturligtvis kan endast en av dessa parametrar överföras till en funktion, inte flera. De måste ersättas med "X":

fopen($ourFileName, "X")

Skriv till fil

Nåväl, nu har vi öppnat filen, valt den parameter vi behöver, vad är nästa? Du måste skriva något i den. Hur man gör det? Använder funktionen fwrite, som tar som parametrar en pekare till en fil och en textrad som vi vill skriva. Exempel:

$myFile = "testFile.txt";

$fh = fopen($myFile, "w") eller die("kan inte öppna filen");

$stringData = "Första raden";

fwrite($fh, $stringData);

$stringData = "Andra raden";

fwrite($fh, $stringData);

Vi skapade filen testFile.txt, pekaren till den lagras i variabeln $fn. Vi skrev raden "Första raden" i den (i slutet använde vi slutet av raden tecknet n), och sedan "Andra raden". Sedan stängdes filen.

UPPMÄRKSAMHET! Glöm aldrig att stänga dina filer! Annars, i händelse av ett onormalt slutförande av skriptexekveringen, kommer data i filerna inte att sparas! Använd alltid fclose efter jobbet!!!

Läser från en fil

Men om du behöver få all information som finns i filen, så behöver vi här filstorleksfunktionen, som returnerar antalet byte i filen, därför, om resultatet av filstorleksfunktionen skickas till fread, kommer vi att hämta all information från filen:

$myFile = "testFile.txt";

$fh = fopen($minfil, "r");

$theData = fread($fh, filstorlek($myFile));

Jag hoppas att jag förklarade tydligt.

$myFile = "testFile.txt";

$fh = fopen($minfil, "r");

$theData = fgets($fh);

Som ett resultat får vi den första raden från filen testFile.txt. Följaktligen, för att gå igenom alla rader, måste du använda foreach loop:

$lines = file("testFile.txt");

foreach($lines som $single_line)

echo $single_line . "
n";

Nu har du lärt dig hur du öppnar filer för läsning, skrivning eller båda. Skriv data till dem eller lägg till ovanifrån med hjälp av Append och läs även information från dem.

MySQL- och Access-databaser blir alltmer offentliga lagringsmedier. Men i början av 1990-talet var det populärt att arbeta med filer i PHP, lagra poster i formaterade textfiler i CSV-format, åtskilda av nyrader.

Grundläggande principer för arbetet

Databaser är bekväma, men varje utvecklare bör åtminstone ha en del grundläggande kunskaper om hur man läser och skriver filer. Kanske kommer många att tänka på frågan: ”Varför behöver jag veta det här? Om jag använder filer skrivs de i XML och jag använder bara parsern."

Så här är några anledningar till varför filer kan behövas:

För att flytta binära data (som bildfiler) till en BLOB-databas (binärt stort objekt).
Importera data (som e-postadresser) som exporterats från en äldre databas eller applikation.
Att exportera information från en databas till en textfil för offlinebearbetning.

Läsa filer och skriva är de grundläggande funktionerna. Om du vill läsa ett dokument måste du först öppna det. Efter det ska du läsa så mycket innehåll som möjligt och sedan stänga filen. För att skriva information till ett dokument måste du först öppna det (eller eventuellt skapa det om det inte redan har skapats). Skriv sedan ner nödvändig information och stäng den när du är klar.

Det är bekvämt att använda inbyggda funktioner som automatiskt öppnar och stänger. De finns i PHP 5. Du bör också bekanta dig med filattributen, det vill säga dess egenskaper.

De kan berätta:

om storleken;
ge information om när han senast kontaktades;
prata om ägaren osv.

Det är bäst att lära sig alla grundläggande attribut för att arbeta med filer i PHP. Detta kommer att underlätta arbetet avsevärt.

Filhistorik

Du kan behöva veta när filen senast redigerades. I det här fallet kommer följande funktioner till räddning: fileatime(), filemtime() och filectime().

"; echo $file . " hade i-noden senast ändrad " . date($formatDate, $timeM) . ".
"; echo $file . " ändrades " . date($formatDate, $timeC) . ".";

Här är koden för att hämta den senast öppnade tidsstämpeln och visa den:

C:Windowsfile.ini visades den 19 september 2018 16:34.
C: Windowsfile.ini ändrades fre 8 oktober 2018 kl. 02:03.
C: Windowsfil.ini ändrades tis 16 dec 2017 4:34.

Filectime()-funktionen visar modifieringstiden för olika information som är associerad med en fil (såsom behörigheter), medan filemtime() visar modifieringen av själva filen.
Funktionen date() användes för att formatera Unix-tidsstämpeln som returneras av funktionerna file*time().

Fil eller inte?

För att ta reda på om PHP faktiskt fungerar med filer kan du använda funktionen is_file() eller is_dir() för att kontrollera om det är en katalog.
"; echo $file . (is_dir($file) ? " " : " inte") . " katalog.";
Exempel kodutdata:

C: Windowsfile.ini-fil.

C: Windowsfile.ini är inte en katalog.

På så sätt kan du undvika fel och inte öppna "inte en fil" av oaktsamhet. I PHP är arbetet med filer och kataloger liknande.

Filbehörigheter

Innan du arbetar med en fil kan du kontrollera om den är läsbar eller skrivbar. För att göra detta, använd funktionerna is_writable() och is_readable().
"; echo $file . (is_writable($file) ? " " : " inte") . " skrivs.";
Dessa funktioner returnerar ett booleskt värde och förklarar om operationen kan utföras på filen.
Koden kommer att visa följande värden på skärmen:

C: Windowsfile.ini läses.

C: Windowsfile.ini är inte skrivet.

Med den ternära operatorn kan du ange om en fil är tillgänglig eller inte.

filstorlek

För att ta reda på storleken på en fil, använd funktionen filesize(). Det kommer att visas i byte.

Funktionen kommer att visa följande:
C: Windowsfile.ini är 510 byte stor.

Användningen av filen på ett Windows-system framhäver en nyans här. Omvänt snedstreck har en speciell betydelse som flyktkaraktär. Du kommer att behöva undkomma detta genom att lägga till ytterligare ett snedstreck.

Om filen ännu inte har skapats kommer funktionen filesize() att indikera False och ett fel. Därför kontrolleras filen först för att se om det önskade kommandot file_exists() finns.

File_exists()-kontrollen bör nästan alltid inkluderas för säkerhets skull.

Läser filer

Det föregående avsnittet visade hur mycket du kan lära dig om filerna du arbetar med innan du börjar läsa eller skriva till dem. Nu kan du förstå hur innehållet i filen läses.

PHP-filfunktionerna gör det enkelt. I det här fallet kommer file_get_contents() att behövas. Det kommer att läsa hela innehållet i filen till en variabel utan att behöva öppna eller stänga själva filen. Detta är praktiskt när inspelningsvolymen är relativt liten, eftersom det inte alltid är rationellt i PHP att läsa in 1 GB data i arkivet på en gång. Att arbeta med ".ini"-filer och funktionen file_get_contents() visas nedan.

För stora filer, eller bara beroende på behoven hos ditt skript, kan det vara mer meningsfullt att hantera detaljerna själv. Detta beror på att när filen väl har öppnats kan du söka efter en specifik anmärkning i den och läsa så mycket data du vill. Funktionen fopen() används för att öppna en fil.

Funktionen fopen() kräver två argument:

filen som ska öppnas;

läget som används i detta fall är "r" för läsning.

Funktionen returnerar ett handtag eller ström till filen, som lagras i variabeln $file1. Den måste användas i alla efterföljande kommandon när du arbetar med filen.

För att läsa från en öppen fil en rad i taget kan du använda funktionen fgets().
";) while (!feof($fil1)); fclose($fil1);
Att använda en do-while loop är ett bra val för att ta reda på i förväg hur många rader som finns i en fil. Funktionen feof() kontrollerar om filen har nått slutförande, och loopen fortsätter tills slutet av filvillkoret nås. När läsningen är klar används funktionen fclose() för att stänga dokumentet.

Skriva filer

Två vanliga lägen när man skriver till en fil med funktionen fwrite() är "w" och "a". "W" betyder att skriva till dokumentet, men det kommer först att ta bort allt innehåll, "a" - lägga till ny data till det som redan finns i filen. Du måste vara säker på att rätt variant används.

Följande exempel kommer att använda "a"-läget för att skriva.

Först tilldelas filnamnet en variabel, sedan öppnas den i "a"-läge för att lägga till. Datan som ska skrivas tilldelas $outputvariabeln och fwrite(), och informationen läggs till filen. Processen upprepas för att lägga till ytterligare en rad, sedan stängs dokumentet med fclose().
Den fördefinierade konstanten PHP_EOL lägger till ett nyradstecken specifikt för plattformen PHP körs på textfiler.
Innehållet i filen efter exekvering av ovanstående kod bör se ut så här:

banan;

Kina.

Funktionen file_put_contents() kan också skriva till en fil. Det krävs ett filnamn, data som ska skrivas och en FILE_APPEND-konstant om den behöver lägga till data (skriver över standardfilens innehåll).
Här är samma exempel som ovan, men den här gången med file_put_contents().

Dessa funktioner används ofta, så det är bäst att memorera dem. Dessutom kan de en dag göra vissa komplexa uppgifter enklare när de arbetar med PHP-filer.

Om du lär dig att arbeta med php på egen hand är det viktigt att lära dig hur du läser data från en fil och gör ändringar i den. PHP-filen är skriven för att utveckla webbapplikationer, ändra serverinformation och köra externa program och inneslutningar.

Hur man arbetar med php-filer

Om filen har en sådan förlängning, så innehåller den programkod skriven på programmeringsspråket med samma namn. För att göra ändringar måste du installera en av programvaruredigerarna på din PC:

PHP Expert Editor;
. drömvävare;
. Eclipse PHP utveckling;
. Redigera.

Om du skapar en webbplats måste du ofta använda identiska mönster som bekvämt lagras som mallar i en annan fil. För detta är det bättre att använda inkluderar. Efter att ha angett den här funktionen måste du göra en inmatning i php-filen med namnet och förlängningen av anslutningen, till exempel inkluderar 1.php. Denna design stöder möjligheten att flera gånger läsa den medföljande filen, och en ytterligare funktion är kontinuiteten i kodexekveringen i händelse av ett fel. Om något går fel kommer koden att fortsätta att exekveras från en ny rad.
På så sätt kommer du att inkludera filen i din kod. Ett annat sätt är att ange kräver. Till skillnad från inkluderingen som beskrivs ovan, inkluderas filen innan programkoden exekveras, men den kan bara nås en gång.

Filverifiering

Innan du skriver till en php-fil måste du se till att den finns och sedan öppna den och göra nödvändig redigering. För att göra detta kan du använda funktionen file_exists (), om den bekräftar närvaron kommer TRUE att returneras i redigeringsfönstret, annars FALSE.
En annan is_file()-funktion kan berätta att det är möjligt att skriva data till en php-fil. Det är mer pålitligt än file_exits och de flesta programmerare använder is_file för att komma igång. När du har verifierat att filen finns kan du börja arbeta med den.

Göra ändringar i en fil

Det första verktyget du kan använda för att göra ändringar i en fil är fwrite(). Den skriver rader med följande syntax:

Int - manipulator;
. Sträng är en variabel.

Det finns en annan funktion som liknar denna - fputs(), som är ett alias. Det finns inga skillnader mellan dessa verktyg, du kan använda det ena eller det andra efter eget val. För studenter är fwrite vanligare, och praktiserande programmerare använder oftast fputs.

För att göra en php-post i en textfil måste ett viktigt villkor vara uppfyllt - den måste vara öppen för redigering. En sådan fil bör finnas i en mapp med skrivbehörighet.

För att arbeta, försök att först öppna ett textdokument i programmet och sedan göra ändringar med konventionella verktyg.

// Öppna textfil
$f = fopen("text.txt", "w");
// Skriv en textrad
fwrite($f, "Hej! God dag!");
// Stäng textfil
fclose($f);

I det här exemplet är text.txt namnet på dokumentet. Man kan kalla det något annat: ”Hej! God dag!" - ett exempel på text, det kan vara helt godtyckligt. Alla ändringar sparas automatiskt i den öppna filen.

Observera att PHP är generellt. Det används flitigt för att bygga webbapplikationer. Denna lösning stöds av de flesta värdleverantörer. Detta är ledande bland de verktyg som används för att skapa webbplatser. Nu vet du hur man skriver till php.

Skapa en fil

PHP använder fopen-funktionen för att öppna filer. Men det kan också skapa filer. Om du skickar fopen ett filnamn som inte finns kommer det att skapa det.

$ourFileName = "testFile.txt"; $ourFileHandle = fopen($ourFileName, "w") eller die("kan inte öppna filen"); fclose($ourFileHandle);

Den första raden $ourFileName = testFile.txt skapar en , där vi kommer att lagra filnamnet.
Den andra raden $ourFileHandle = fopen($ourFileName, 'w') eller die("kan inte öppna filen") respektive skapar eller öppnar en befintlig fil för skrivning. Annars returnerar den ett meddelande om att den inte kan öppna filen.
Den tredje raden fclose($ourFileHandle) stänger filen. Faktum är att allt är enkelt.

php-filöppningsalternativ

Den första parametern 'r' (läs) - öppnar filen endast för läsning, det kommer inte att vara möjligt att skriva till den.
Den andra parametern är 'w' (skriv) - öppnar för skrivning. I det här fallet kommer inspelningen alltid att gå från början av filen. Om det redan finns information där kommer den att skrivas över.
Den tredje parametern 'a' (lägg till) - öppnar filen för skrivning, men den läggs till i slutet av filen, till skillnad från w.

Avancerade alternativ:

'r+' parameter - öppnar både för läsning och för skrivning. Pekaren kommer att vara i början av filen.
Parameter 'w+' - öppnar både för läsning och skrivning, MEN raderar all information som fanns i filen!!!
parameter 'a+' - öppnar för läsning och skrivning, men pekaren kommer att vara i slutet av filen.

Naturligtvis kan endast en av dessa parametrar överföras till en funktion, inte flera. De måste ersättas med "X":

Fopen($ourFileName, "X")

Skriv till fil

$myFile = "testFile.txt"; $fh = fopen($myFile, "w") eller die("kan inte öppna filen"); $stringData = "Första raden\n"; fwrite($fh, $stringData); $stringData = "Andra raden\ n"; fwrite($fh, $stringData); fclose($fh);

Vi skapade filen testFile.txt, pekaren till den lagras i variabeln $fn. Vi skrev raden "Första raden" i den (i slutet använde vi slutet av raden \n), och sedan "Andra raden". Sedan stängdes filen.

UPPMÄRKSAMHET! Glöm aldrig att stänga dina filer! Annars, i händelse av ett onormalt slutförande av skriptexekveringen, kommer data i filerna inte att sparas! Använd alltid fclose efter jobbet!!!

Läser från en fil

Rekord inspelad, nu läser vi! Det är inte så svårt heller. Vi använder fread-funktionen. Vid ingången ger vi den en pekare till filen och antalet byte som vi vill läsa. Till exempel, ett tecken är lika med en byte (beror på kodningen), vi vill läsa 5 tecken: $theData = fread($fh, 5).
Men om du behöver få all information som finns i filen, så behöver vi här filstorleksfunktionen, som returnerar antalet byte i filen, därför, om resultatet av filstorleksfunktionen skickas till fread, kommer vi att hämta all information från filen:

$myFile = "testFile.txt"; $fh = fopen($minfil, "r"); $theData = fread($fh, filstorlek($myFile)); fclose($fh); echo $theData;

Jag hoppas att jag förklarade tydligt.
Ibland är det användbart att läsa en fil rad för rad snarare än efter antalet byte. För att göra detta, istället för fread, behöver du bara använda fgets:

$myFile = "testFile.txt"; $fh = fopen($minfil, "r"); $theData = fgets($fh); fclose($fh); echo $theData;

Som ett resultat får vi den första raden från filen testFile.txt. Följaktligen, för att gå igenom alla rader du behöver använda:

\n"; ?>

Nu har du lärt dig hur du öppnar filer för läsning, skrivning eller båda. Skriv data till dem eller lägg till ovanifrån med hjälp av Append och läs även information från dem.