Voordat u met een bestand probeert te werken, is het raadzaam om ervoor te zorgen dat het bestaat. Om dit probleem op te lossen worden meestal twee functies gebruikt:
file_exists() en is_file().
De functie file_exists() controleert of een bepaald bestand bestaat. Als het bestand bestaat, retourneert de functie TRUE, anders wordt FALSE geretourneerd. De syntaxis van de functie file_exists() is:
bool file_exists(tekenreeksbestand)
Een voorbeeld van het controleren van het bestaan van een bestand:
if (!file_exists($filename)) :
print "Bestand $bestandsnaam bestaat niet!";
is_bestand()
De functie is_file() controleert het bestaan van een bepaald bestand en of het gelezen/geschreven kan worden. In wezen is is_file() een robuustere versie van file_exists() die niet alleen controleert of een bestand bestaat, maar ook of het gegevens kan lezen en schrijven:
bool is_file(tekenreeksbestand)
In het volgende voorbeeld ziet u hoe u kunt verifiëren dat een bestand bestaat en dat er bewerkingen op kunnen worden uitgevoerd:
$file = "eenbestand.txt";
if (is_bestand($bestand)) :
print "Het bestand $file is geldig en bestaat!";
print "Het bestand $file bestaat niet of is geen geldig bestand!";
Nadat u zich ervan heeft verzekerd dat het gewenste bestand bestaat en dat er verschillende lees-/schrijfbewerkingen mee kunnen worden uitgevoerd, kunt u doorgaan naar de volgende stap: het openen van het bestand.
De functie filesize() retourneert de grootte (in bytes) van het bestand met de opgegeven naam, of FALSE bij een fout. Syntaxis van de functie Filesize():
int bestandsgrootte(string bestandsnaam)
Stel dat u de grootte van het Pastis.txt-bestand wilt bepalen. Om de benodigde informatie te verkrijgen, kunt u de functie filesize() gebruiken:
$fs = bestandsgrootte("gebak.txt"); print "Gebak.txt is $fs bytes.";
Het volgende resultaat wordt weergegeven:
Pastry.txt is 179 bytes groot.
Voordat u bewerkingen op een bestand kunt uitvoeren, moet u het openen en aan een bestandshandler koppelen. Nadat u klaar bent met het werken met het bestand, moet u het sluiten. Deze onderwerpen worden in het volgende gedeelte behandeld.
Bestanden openen en sluiten
Voordat u I/O op een bestand kunt uitvoeren, moet u het openen met fopen().
De functie fopen() opent een bestand (als dit bestaat) en retourneert een geheel getal -- genaamd bestandsmanipulator(vijlhandvat). syntaxis van de functie fopen():
int fopen (stringbestand, stringmodus [, int enable_path])
Het bestand dat wordt geopend kan zich op het lokale bestandssysteem bevinden, bestaan als een standaard invoer/uitvoerstroom, of een bestand vertegenwoordigen op een extern systeem dat wordt geaccepteerd via HTTP of FTP.
De bestandsparameter kan in verschillende vormen worden gespecificeerd, hieronder vermeld:
Als de parameter de naam van een lokaal bestand bevat, opent fopen() dat bestand en retourneert een handle.
Als de parameter is opgegeven als php://stdin, php://stdout of php://stderr, wordt de overeenkomstige standaard invoer/uitvoerstroom geopend.
Als de parameter begint met het voorvoegsel http://, opent de functie een HTTP-verbinding met de server en retourneert een handle voor het opgegeven bestand.
Als de parameter begint met het voorvoegsel ftp://, opent de functie een FTP-verbinding met de server en retourneert een handle voor het opgegeven bestand. Er zijn in dit geval twee dingen waar u bijzondere aandacht aan moet besteden: Als de server de passieve FTP-modus niet ondersteunt, zal de fopen()-aanroep mislukken. Bovendien worden FTP-bestanden geopend om te lezen of te schrijven.
Wanneer de YAR-server in de passieve modus werkt, wacht hij op verbindingen van clients. Bij gebruik in de actieve modus brengt de server zelf een verbinding met de client tot stand. De standaardinstelling is meestal de actieve modus.
De modusparameter bepaalt de mogelijkheid om het bestand te lezen en ernaar te schrijven. In tabel 7.1 somt enkele waarden op die de openingsmodus van het bestand bepalen.
Tabel 7.1. Modi voor het openen van bestanden
| Modus | Beschrijving |
| Alleen lezen. De huidige positieaanwijzer wordt ingesteld op het begin van het bestand | |
| r+ | Lezen en schrijven. De huidige positieaanwijzer wordt ingesteld op het begin van het bestand |
| w | Alleen opnemen. De huidige positieaanwijzer wordt ingesteld op het begin van het bestand en de volledige inhoud van het bestand wordt vernietigd. Als het bestand niet bestaat, probeert de functie het te maken |
| w+ | Lezen en schrijven. De huidige positieaanwijzer wordt ingesteld op het begin van het bestand en de volledige inhoud van het bestand wordt vernietigd. Als het bestand niet bestaat, probeert de functie het te maken |
| A | Alleen opnemen. De huidige positieaanwijzer wordt ingesteld op het einde van het bestand. Als het bestand niet bestaat, probeert de functie het te maken |
| een+ | Lezen en schrijven. De huidige positieaanwijzer wordt ingesteld op het einde van het bestand. Als het bestand niet bestaat, probeert de functie het te maken |
Als de optionele derde parameter include_path 1 is, dan is het bestandspad relatief ten opzichte van de include-map die is opgegeven in het php.ini-bestand (zie hoofdstuk 1).
Hieronder ziet u een voorbeeld van het openen van een bestand met de functie fopen(). De die()-aanroep, gebruikt in combinatie met fopen(), geeft een foutmelding als het bestand niet kan worden geopend:
$file = "gebruikersdata.txt"; // Een bestand
$fh = fopen($file, "a+") or die("Bestand ($bestand) bestaat niet!");
Het volgende fragment opent een verbinding met de PHP-site (http://www.php.net):
$site = "http://www.php.net": // Server toegankelijk via HTTP
$sh = fopen($site., "r"); //Koppel de manipulator aan de Php.net-indexpagina
Na voltooiing van het werk moet het bestand altijd worden gesloten met fclose().
De functie fclose() sluit een bestand met de gegeven manipulator. Als het sluiten succesvol is, wordt TRUE geretourneerd; als het sluiten niet lukt, wordt FALSE geretourneerd. fclose() functiesyntaxis:
int fclose(int-manipulator)
De functie fclose() sluit met succes alleen die bestanden die eerder zijn geopend door de functies fopen() of fsockopen(). Voorbeeld van het sluiten van een bestand:
$file = "gebruikersdata.txt";
if (file_exists($file)) :
$fh = fopen($bestand, "r");
// Voer bestandsbewerkingen uit
print "Bestandsbestand bestaat niet!";
Naar bestand schrijven
Er worden twee hoofdbewerkingen uitgevoerd op geopende bestanden: lezen en schrijven.
De functie is_writeable() verifieert dat een bestand bestaat en beschrijfbaar is. De schrijfbaarheid wordt gecontroleerd voor zowel het bestand als de map. De syntaxis van de functie is_writeable() is:
bool is_writeable (tekenreeksbestand)
Een belangrijk ding om op te merken is dat PHP hoogstwaarschijnlijk zal draaien onder het gebruikers-ID dat door de webserver wordt gebruikt (meestal "niemand"). Een voorbeeld van het gebruik van is_writeable() wordt gegeven in de beschrijving van de functie fwrite().
De functie fwrite() schrijft de inhoud van een stringvariabele naar het bestand dat is opgegeven door de bestandshandler. fwrite() functiesyntaxis:
int fwrite(int-manipulator, stringvariabele [, int-lengte])
Als de optionele lengteparameter wordt doorgegeven bij het aanroepen van de functie, stopt het schrijven nadat het opgegeven aantal tekens is geschreven of wanneer het einde van de regel is bereikt. Het controleren of er naar een bestand kan worden geschreven, wordt gedemonstreerd in het volgende voorbeeld:
// Informatie over verkeer op de gebruikerssite
$data = "08:13:00|12:37:12|208.247.106.187|Win98";
$bestandsnaam = "eenbestand.txt";
// Als het bestand bestaat en ernaar kan worden geschreven
if (is_writeable($bestandsnaam)) :
$fh = fopen($bestandsnaam, "a+");
// Schrijf de inhoud van $data naar een bestand
$ succes - fwrite($fh, $data);
// Bestand sluiten
fsluiten($fh); anders:
print "Kon bestandsnaam niet openen om te schrijven";
De functie fputs() is een alias voor fwrite() en kan overal worden gebruikt waar fwrite() wordt gebruikt.
De functie fputs() is een alias voor fwrite() en heeft exact dezelfde syntaxis. fputs() functiesyntaxis:
int fputs(int-manipulator, stringvariabele [, int-lengte])
Persoonlijk gebruik ik liever fputs(). Houd er rekening mee dat dit slechts een kwestie van stijl is en niets te maken heeft met eventuele verschillen tussen de twee functies.
Lezen uit een bestand
Lezen is ongetwijfeld de belangrijkste bewerking die op bestanden wordt uitgevoerd. Hieronder staan enkele functies die het lezen uit een bestand efficiënter maken. De syntaxis van deze functies kopieert vrijwel exact de syntaxis van vergelijkbare opnamefuncties.
Met de functie i s_readable() kunt u verifiëren dat het bestand bestaat en leesbaar is. De leesbaarheid wordt gecontroleerd voor zowel het bestand als de directory. De syntaxis van de functie is_readable() is:
boe! is_leesbaar(tekenreeksbestand]
Hoogstwaarschijnlijk zal PHP draaien onder het gebruikers-ID dat door de webserver wordt gebruikt (meestal "niemand"), dus om de functie is_readable() TRUE te laten retourneren, moet het bestand door iedereen gelezen mogen worden. In het volgende voorbeeld ziet u hoe u kunt verifiëren dat een bestand bestaat en leesbaar is:
if (is_leesbaar($bestandsnaam)) :
// Open het bestand en stel de huidige positieaanwijzer in op het einde van het bestand
$fh = fopen($bestandsnaam, "r");
print "$bestandsnaam is niet leesbaar!";
De functie fread() leest het opgegeven aantal bytes uit een bestand dat is opgegeven door de bestandsmanipulator. fwrite() functiesyntaxis:
int fread(int manipulator, int lengte)
De manipulator moet verwijzen naar een open bestand dat leesbaar is (zie de beschrijving van de functie is_readable()). Het lezen stopt nadat een bepaald aantal bytes is gelezen of wanneer het einde van het bestand is bereikt. Beschouw het tekstbestand gebak.txt dat wordt weergegeven in Listing 7.1. Het lezen en uitvoeren van dit bestand in de browser gebeurt door het volgende fragment:
$fh = fopen("pastry.txt", "r") or die("Kan bestand niet openen!");
$bestand = fread($fh, bestandsgrootte($fh));
Door de functie fllesize() te gebruiken om de grootte van gebak.txt in bytes te bepalen, zorgt u ervoor dat de functie fread() de volledige inhoud van het bestand leest.
Lijst 7.1. Tekstbestand gebak.txt
Recept: Banketdeeg
1 1/4 kopjes bloem voor alle doeleinden
3/4 stokje (6 eetlepels) ongezouten boter, gehakt
2 eetlepels plantaardig bakvet 1/4 theelepel zout
3 eetlepels water
De functie fgetc() retourneert een tekenreeks met daarin één teken uit het bestand op de huidige pointerpositie, of FALSE wanneer het einde van het bestand is bereikt. fgetc() functiesyntaxis:
string fgetc (int-manipulator)
De manipulator moet verwijzen naar een open bestand dat leesbaar is (zie de beschrijving van de functie is_readable() eerder in dit hoofdstuk). Het volgende voorbeeld demonstreert het karakter voor karakter lezen en uitvoeren van een bestand met behulp van de fgetc() functie:
$fh = fopen("gebak.txt", "r"); while (!feof($fh)) :
$char = fgetc($fh):
print $char; eindtijd;
De functie fgets() retourneert een tekenreeks die wordt gelezen vanaf de huidige pointerpositie in het bestand dat is opgegeven door de bestandshandler. De bestandsaanwijzer moet verwijzen naar een geopend bestand dat leesbaar is (zie de beschrijving van de functie is_readable() eerder in dit hoofdstuk). fgets() functiesyntaxis:
string fgets (int-manipulator, int-lengte)
Het lezen stopt wanneer aan een van de volgende voorwaarden wordt voldaan:
- lezen vanaf bestandslengte -- 1 byte;
- er is een newline-teken uit het bestand gelezen (opgenomen in de geretourneerde tekenreeks);
- De einde-bestandsvlag (EOF) is uit het bestand gelezen.
Als u het lezen van een bestand regel voor regel wilt organiseren, geeft u in de tweede parameter een waarde op die duidelijk groter is dan het aantal bytes in de regel. Voorbeeld van het regel voor regel lezen en uitvoeren van een bestand:
$fh = fopen("gebak.txt", "r");
while (!feof($fh));
$lijn = fgets($fh, 4096);
$regel afdrukken. "
";
De functie fgetss() is volledig vergelijkbaar met fgets() met één uitzondering: het probeert alle HTML- en PHP-tags uit de gelezen tekst te verwijderen:
string fgetss (Int-manipulator, int-lengte [, string toegestane_tags])
Voordat u verdergaat met de voorbeelden, bekijkt u eerst de inhoud van Listing 7.2. Dit bestand wordt gebruikt in Listing 7.3 en 7.4.
Lijst 7.2. Bestand wetenschap.html
Buitenaardse levensvorm ontdekt
20 augustus 2000
Vanochtend vroeg werd er een vreemde nieuwe vorm van schimmel gevonden die groeide in de kast van de oude koelkast van W. J. Gilmore. Het is niet bekend of de krachtige straling afkomstig van de computermonitor van de huurder aan deze evolutie heeft bijgedragen.
Lijst 7.3. Tags verwijderen uit een HTML-bestand voordat het in de browser wordt weergegeven
$fh = fopen("wetenschap.html", "r");
while (!feof($fh)) :
print fgetss($fh, 2048);
Het resultaat ziet u hieronder. Zoals je kunt zien zijn alle HTML-tags verwijderd uit het science.html-bestand, waardoor de opmaak verloren is gegaan:
In sommige situaties worden op enkele na alle tags uit een bestand verwijderd, bijvoorbeeld regeleindetags
. Lijst 7.4 laat zien hoe dit wordt gedaan.
Lijst 7.4. Selectief tags verwijderen uit een HTML-bestand
$fh = fopenC"wetenschap.html", "r");
$toegestaan = "
";
while (!feof($fh)) :
print fgetss($fh. 2048, $allowable);
Resultaat:
Breaking News - Wetenschap Buitenaardse levensvorm ontdekt op 20 augustus 2000 Vanochtend vroeg werd er een vreemde nieuwe vorm van schimmel gevonden die groeide in de kast van de oude koelkast van het appartement van W.J. Gilmore. Het is niet bekend of de krachtige straling afkomstig van de computermonitor van de huurder hierbij heeft geholpen evolutie.
Zoals u kunt zien, maakt de functie fgetss() bestandsconversie eenvoudig, vooral als u een groot aantal vergelijkbaar opgemaakte HTML-bestanden heeft.
Een bestand in een array lezen
De functie file() laadt de volledige inhoud van een bestand in een indexeerbare array. Elk element van de array komt overeen met één regel van het bestand. Functiesyntaxis van Bestand():
array-bestand (stringbestand [, int include_path])
Als de optionele derde parameter include_path 1 is, dan is het bestandspad relatief ten opzichte van de include-map die is opgegeven in het bestand php.ini (zie hoofdstuk 1). Listing 7.5 gebruikt de functie file() om het bestand baking.txt te laden (zie Listing 7.1).
$file_array = bestand("gebak.txt");
while (lijst($line_num. $line) = Eacht($file_array)):
afdrukken " Regel $line_num:", htmlspecialchars($line), "
\N"
Elke rij van de array wordt afgedrukt samen met een nummer:
Regel 0: Recept: Gebakdeeg
Lijn 1: 1 1/4 kopjes bloem voor alle doeleinden
Lijn 2: 3/4 stokje (6 eetlepels) ongezouten boter, gehakt
Regel 3: 2 eetlepels plantaardig bakvet
Lijn 4: 1/4 theelepel zout
Lijn 5: 3 eetlepels water
Een bestand omleiden naar standaarduitvoer
De functie readfile() leest de inhoud van een bestand en schrijft deze naar standaarduitvoer (in de meeste gevallen naar de browser). syntaxis van de functie readfile():
int leesbestand (tekenreeksbestand [, int include_path])
De functie retourneert het aantal gelezen bytes. Het bestand kan zich op het lokale bestandssysteem bevinden, bestaan als standaard invoer/uitvoer, of het bestand vertegenwoordigen op een extern systeem dat wordt geaccepteerd via HTTP of FTP. De bestandsparameter wordt ingesteld volgens dezelfde regels als in de functie fopen().
Stel dat u een bestand latorre.txt heeft, waarvan u de inhoud in de browser wilt weergeven:
Restaurant "La Torre." gevestigd in Nettuno, Italië, biedt een eclectische mix van stijl. geschiedenis en een verfijnde viskeuken. Binnen de muren van de middeleeuwse borgo die de stad omringt, kun je dineren terwijl je kijkt naar de voorbijgangers die winkelen in de boetieks van het dorp. Comfort gecombineerd met alleen de meest verse zeeproducten maken La Torre tot een van de beste restaurants van Italië.
Wanneer het volgende fragment wordt uitgevoerd, wordt de volledige inhoud van latorre.txt naar standaarduitvoer verzonden:
$restaurant_file = "latorre.txt";
// Stuur het volledige bestand naar standaarduitvoer
leesbestand($restaurant_file);
Een procesbestandshandler openen
Naast gewone bestanden kunt u bestandsmanipulatoren openen om te communiceren met processen op de server. Het probleem wordt opgelost door de functie popen(), die de volgende syntaxis heeft:
int popen (stringopdracht, stringmodus)
De opdrachtparameter specificeert de systeemopdracht die moet worden uitgevoerd, en de modusparameter beschrijft de toegangsmodus:
// Open het bestand "spices.txt" om te schrijven
$fh = fopen("kruiden.txt","w");
// Voeg enkele regels tekst toe
fputs($fh, "Peterselie, salie, rozemarijn\n");
fputs($fh, "Paprika, zout, peper\n");
fputs($fh, "Basilicum, salie, gember\n");
// Sluit de manipulator
// Open een UNIX grep-proces om naar het woord Basilicum te zoeken in het bestand spice.txt
$fh - popen("grep Basilicum< spices.txt", "r");
// Druk het resultaat van grep af
Het resultaat ziet er als volgt uit:
Basilicum, salie, gember
De functie fpassthru() is vergelijkbaar met de functie passthru() die wordt besproken in de sectie 'Externe programma's uitvoeren' van dit hoofdstuk.
Nadat alle handelingen zijn voltooid, moet het bestand of proces worden gesloten. De functie pclose() sluit de verbinding met het proces dat is opgegeven door de manipulator, vergelijkbaar met de manier waarop de functie fclose() een bestand sluit dat is geopend door de functie fopen(). pclose() functiesyntaxis:
int pclose (int-manipulator)
In de parameter manipulator de manipulator die eerder werd ontvangen met een succesvolle aanroep van popen() wordt verzonden.
Een stopcontactaansluiting openen
PHP beperkt zich niet tot interactie met bestanden en processen; je kunt ook verbindingen maken via sockets. Stopcontact Een socket is een softwareabstractie waarmee u met verschillende services op een andere computer kunt communiceren.
De functie fsockopen() brengt een socketverbinding tot stand met een server op internet
via TCP- of UDP-protocol. fsockopen() functiesyntaxis:
int fsockopen (string knooppunt, int poort [, int error_code [, string error_text [, int time-out]]])
De optionele parameters error_code en error_text bevatten informatie die wordt weergegeven als de verbinding met de server mislukt. Beide parameters moeten ter referentie worden doorgegeven. De derde optionele parameter, time-out, specificeert de tijdsduur die moet worden gewacht op een antwoord van de server (in seconden). Listing 7.6 demonstreert het gebruik van de functie fsockopen() om serverinformatie te verkrijgen. Voordat u Listing 7.6 bekijkt, is er echter nog één functie die u moet kennen: socket_set_blocking().
UDP (User Datagram Protocol) is een verbindingsloos communicatieprotocol.
socket_set_blocking()
Met de functie socket_set_b1ocki ng() kunt u time-outcontrole instellen voor serverbewerkingen:
socket_set_blocking (int-manipulator, booleaanse modus)
De manipulatorparameter specificeert de eerder geopende socket, en de modusparameter selecteert de modus waarnaar de socket wordt geschakeld (TRUE voor blokkerende modus, FALSE voor niet-blokkerende modus). Een voorbeeld van het gebruik van de functies fsockopen() en socket_set_blocking() wordt getoond in Listing 7.6.
Lijst 7.6. Gebruik fsockopen() om serverinformatie op te halen
functie getthehost($host.$pad) (
// Open verbinding met knooppunt
$fp - fsockopen($host, 80, &$errno, &$errstr, 30);
// Ga naar de blokkeermodus
socket_set_blocking($fp, 1),
// Stuur headers
fputs($fp,"GET $pad HTTP/1.1\r\n");
fputs($fp, "Host: $host\r\n\r\n"); $x = 1;
// Haal kopteksten op
terwijl($x< 10) :
$headers = fgets($fp, 4096);
// Sluit de manipulator
getthehost("www.apress.com", "/");
Running Listing 7.6 produceert de volgende uitvoer:
HTTP/1.1 200 OK Server: Microsoft-IIS/4.0 Inhoudslocatie:
2000 20:25:06 GMT ETag: "f0a61666dbff1bf1:34a5" Inhoudslengte: 1311
De functie pfsockopen() is een persistente versie van fsockopen(). Dit betekent dat de verbinding niet automatisch wordt verbroken als het script waarin de functie is aangeroepen eindigt. De syntaxis van de functie pfsockopen() is:
int pfsockopen (string knooppunt, int poort [, int error_code [, string error_text [, int time-out]]])
Afhankelijk van de specifieke doelen van uw toepassing, vindt u het wellicht handiger om pfsockopen() te gebruiken in plaats van fsockopen().
Externe programma's lanceren
PHP-scripts kunnen ook programma's uitvoeren die zich op de server bevinden. Deze functie wordt vooral vaak gebruikt bij het beheer van het systeem via een webbrowser, maar ook om gemakkelijker samenvattingsinformatie over het systeem te verkrijgen.
De functie exec() voert een bepaald programma uit en retourneert de laatste regel van de uitvoer ervan. Syntaxis van de functie exec():
string exec (stringopdracht [, string array [, int return]])
Houd er rekening mee dat de functie exec() alleen de opdracht uitvoert en de resultaten niet afdrukt. Alle opdrachtuitvoer kan worden opgeslagen in een optionele arrayparameter. Als er bovendien een return-variabele wordt opgegeven wanneer de array-parameter wordt opgegeven, wordt aan deze laatste de return-code van de uitgevoerde opdracht toegewezen.
Listing 7.7 laat zien hoe u de functie exec() gebruikt om de UNIX-ping-systeemfunctie uit te voeren.
Lijst 7.7. Verbinding met de server controleren met behulp van de exec()-functie
exec("ping -van 5 www.php.net", $ping);
// Op Windows - exec("ping -n 5 www.php.net. $ping);
voor ($i=0; $i< count($ping);$i++) :
afdrukken "
$ping[$i]";
Resultaat:
PING www.php.net (208.247.106.187): 56 databytes
64 bytes van 208.247.106.187: icmp_seq=0 ttl=243 tijd=66.602 ms
64 bytes van 208.247.106.187: icmp_seq=1 ttl=243 tijd=55.723 ms
64 bytes van 208.247.106.187: icmp_seq=2 ttl=243 tijd=70.779 ms
64 bytes van 208.247.106.187: icmp_seq=3 ttl=243 tijd=55.339 ms
64 bytes van 208.247.106.187: icmp_seq=4 ttl=243 tijd=69.865 ms
www.php.net pingstatistieken --
5 pakketten verzonden. 5 pakjes ontvangen. 0% pakketverlies
retour min/avg/max/stddev - 55,339/63,662/70,779/6,783 ms
Achterste apostrofs
Er is een andere manier om systeemopdrachten uit te voeren waarvoor geen aanroepfuncties nodig zijn: de opdracht die wordt uitgevoerd, is omsloten door backticks (` `) en de resultaten van de bewerking worden weergegeven in de browser. Voorbeeld:
afdrukken "
$uitvoer";
Dit fragment geeft de inhoud weer van de map waarin het script zich in de browser bevindt.
De interne parameter ping -c 5 (-p 5 op Windows) specificeert het aantal serverpolls.
Als u alleen de ongeformatteerde resultaten van een opdracht wilt retourneren, gebruikt u de hieronder beschreven functie passthru().
De functie passthru() werkt vrijwel hetzelfde als exec(), met één uitzondering: hij drukt automatisch de resultaten van de opdracht af. Passthru()-functiesyntaxis:
void passthru(stringopdracht [, int return])
Als er een optionele return-parameter wordt doorgegeven bij het aanroepen van passthru(), wordt deze variabele ingesteld op de return-code van het uitgevoerde commando.
escapeshellcmd()
De functie escapeshellcmd() ontwijkt alle potentieel gevaarlijke tekens die door de gebruiker kunnen worden ingevoerd (bijvoorbeeld op een HTML-formulier) om de opdrachten exec(), passthru(), system() of popen() uit te voeren. Syntaxis:
string escapeshellcmd (stringopdracht)
Gebruikersinvoer moet altijd met enige voorzichtigheid worden behandeld, maar toch kunnen gebruikers opdrachten invoeren die worden uitgevoerd door systeemopdrachtfuncties. Beschouw het volgende fragment:
$user_input = `rm -rf *`; // Verwijder de bovenliggende map en al zijn submappen
exec($user_input); // Voer $user_input uit!!!
Als er geen voorzorgsmaatregelen worden genomen, zal een dergelijk bevel tot een ramp leiden. U kunt echter de functies escapeshellcmd() gebruiken om gebruikersinvoer te ontsnappen:
$user_input = `rm - rf *`; // Verwijder de bovenliggende map en al zijn submappen
ex(escapeshellcmd($user_input)); // Ontsnap aan gevaarlijke karakters
De functie escapeshellcmd() ontsnapt aan het teken *, waardoor wordt voorkomen dat de opdracht catastrofale gevolgen heeft.
Beveiliging is een van de belangrijkste aspecten van webprogrammering, dus heb ik een heel hoofdstuk gewijd aan dit onderwerp en hoe dit zich verhoudt tot PHP-programmering. Zie hoofdstuk 16 voor meer informatie.
Werken met het bestandssysteem
PHP heeft functies voor het bekijken en uitvoeren van verschillende bewerkingen op bestanden op de server. Informatie over de kenmerken van serverbestanden (locatie, eigenaar en rechten) is vaak nuttig.
De functie basename() extraheert de bestandsnaam uit de doorgegeven volledige naam. Functiesyntaxis van basisnaam():
string basisnaam(string volledige_naam)
Het extraheren van de basisbestandsnaam uit de volledige naam gaat als volgt:
$pad = "/usr/local/phppower/htdocs/index.php"; $bestand = basisnaam($pad); // $file = "index.php"
In feite verwijdert deze functie het pad uit de volledige naam en laat alleen de bestandsnaam over.
De functie getlastmod() retourneert de datum en tijd van de laatste wijziging van de pagina van waaruit de functie wordt aangeroepen. Syntaxis van de Getlastmod()-functie:
int getlastmod(nietig)
De geretourneerde waarde volgt de UNIX-datum/tijd-notatie en u kunt de functie date() gebruiken om deze op te maken. In het volgende fragment wordt de datum weergegeven waarop de pagina voor het laatst is gewijzigd:
echo "Laatst gewijzigd: ".date("H:i:s a". getlastmod());
De functie stat() retourneert een indexeerbare array met gedetailleerde informatie over het bestand met de opgegeven naam:
array stat(string bestandsnaam)
De volgende informatie wordt geretourneerd in de array-elementen:
0 Apparaat
2 Beschermingsmodus voor indexknooppunten
3 Aantal schakels
4 Eigenaar gebruikers-ID
5 Eigenaarsgroep-ID
6 Apparaattype indexknooppunt
7 Grootte in bytes
8 Tijdstip van laatste oproep
9 Tijdstip van laatste wijziging
10 Laatst gewijzigde tijd
11 Blokgrootte voor I/O van bestandssysteem
12 Aantal toegewezen blokken
Als u dus wilt weten wanneer een bestand voor het laatst is geopend, kijk dan naar element 8 van de geretourneerde array. Laten we eens kijken naar een voorbeeld:
$bestand - "gegevensbestand.txt";
list($dev, $inode, $inodep, $nlink, $uid, $gid, $inodev, $size, $atime, $mtime, $ctime,
$bgrootte) = stat($bestand);
print "$bestand is $size bytes.
";
print "Laatste toegangstijd: $atime
";
print "Laatste wijzigingstijd: $mtime
";
Resultaat:
popen.php is 289 bytes.
Laatste toegangstijd: 15 augustus 2000 12:00:00
Laatste wijzigingstijd: 15 augustus 2000 10:07:18
In dit voorbeeld heb ik de constructie list() gebruikt om namen aan elke geretourneerde waarde toe te wijzen. Natuurlijk kun je net zo gemakkelijk een array retourneren, de elementen doorlussen en alle benodigde informatie weergeven. Zoals u kunt zien, kunt u met de functie stat() verschillende nuttige informatie over een bestand verkrijgen.
Bestandskenmerken weergeven en wijzigen
Elk bestand op UNIX-familiesystemen heeft drie belangrijke kenmerken:
- behoren tot een groep;
- eigenaar;
- machtigingen.
Al deze kenmerken kunnen worden gewijzigd met behulp van de juiste PHP-functies. De functies die in dit gedeelte worden beschreven, werken niet op Windows-familiesystemen.
Als u geen ervaring hebt met UNIX-besturingssystemen, kunt u informatie over de kenmerken van het UNIX-bestandssysteem vinden op http://sunsite.auc.dk/linux-newbie/FAQ2.htm. De onderwerpen groepslidmaatschap, eigendom en machtigingen worden besproken in paragraaf 3.2.6.
De functie chgrp() probeert de groep te wijzigen waartoe een bepaald bestand behoort. chgrp() functiesyntaxis:
int chgrp (string bestandsnaam, gemengde groep)
De functie filegroup() retourneert de groeps-ID van de eigenaar van het bestand met de opgegeven naam, of FALSE bij een fout. Syntaxis van de functie Bestandsgroep():
int bestandsgroep (string bestandsnaam)
De functie chmod() wijzigt de rechten van een bestand met de opgegeven naam. chmod() functiesyntaxis:
int chmod (tekenreeksbestandsnaam, int-machtigingen)
Machtigingen worden gespecificeerd in octale notatie. De details van het instellen van een parameter voor de functie chmod() worden gedemonstreerd in het volgende voorbeeld:
chmod("data_bestand.txt", g+r); // Werkt niet
chmod("data_bestand.txt", 766); // Werkt niet
chmod("data_bestand.txt", 0766); // Werkt
De functie fileperms() retourneert de machtigingen van het bestand met de opgegeven naam, of FALSE bij een fout. Fileperms() functiesyntaxis:
int fileperms (string bestandsnaam)
De functie chown() probeert de eigenaar van een bestand te wijzigen. Het recht om de eigenaar van een bestand te wijzigen is beperkt tot de bevoorrechte gebruiker. chown() functiesyntaxis:
int chown (string bestandsnaam, gemengde gebruiker)
De functie fileowner() retourneert het gebruikers-ID voor de eigenaar van het bestand met de opgegeven naam. Syntaxis van de functie Fileowner():
int bestandseigenaar (string bestandsnaam)
Bestanden kopiëren en hernoemen
Andere nuttige systeemfuncties die in PHP-scripts kunnen worden uitgevoerd, zijn onder meer het kopiëren en hernoemen van bestanden op de server. Deze bewerkingen worden uitgevoerd door twee functies: copy() en rename().
Het kopiëren van een bestand in een PHP-script is niet moeilijker dan het gebruik van de UNIX cf-opdracht. Het probleem wordt opgelost door de PHP-functie copy(). De syntaxis van de functie soru() is:
int copy (stringbron, stringbestemming)
De functie copy() probeert het bronbestand naar het doelbestand te kopiëren; retourneert TRUE bij succes, FALSE bij mislukking. Als het doelbestand niet bestaat, maakt de functie copy() het aan. In het volgende voorbeeld ziet u hoe u een reservekopie van een bestand kunt maken met behulp van de functie copy():
$data_file = "data.txt";
copy($data_file. $data_file.bak") or die("Kan $data_file niet kopiëren");
De functie rename() hernoemt een bestand. Als dit lukt, wordt TRUE geretourneerd en als dit niet lukt, wordt FALSE geretourneerd. Syntaxis van de functie Rename():
bool hernoemen (string oude_naam, string nieuwe_naam)
Een voorbeeld van het hernoemen van een bestand met behulp van de rename() functie:
$data_file = "data.txt";
rename($data file, $datafile.old") or die("Kan $data file niet hernoemen");
Bestanden verwijderen
De functie unlink() verwijdert een bestand met de opgegeven naam. Syntaxis:
int unlink (tekenreeksbestand)
Als u met PHP op een Windows-systeem werkt, kunt u soms problemen ondervinden bij het gebruik van deze functie. In dit geval kunt u de hierboven beschreven functie system() gebruiken en het bestand verwijderen met de DOS del-opdracht:
system("del bestandsnaam.txt");
Werken met catalogi
Met PHP-functies kunt u de inhoud van mappen bekijken en navigeren. Listing 7.8 toont een typische mapstructuur op een UNIX-systeem.
Lijst 7.8. Typische directorystructuur
De functie dirname() is een aanvulling op basename() - hij extraheert het pad uit de volledig gekwalificeerde bestandsnaam. De syntaxis van de functie dirname() is:
string mapnaam (tekenreekspad)
Een voorbeeld van het gebruik van dirname() om een pad uit een volledige naam te extraheren:
$pad = "/usr/locla/phppower/htdocs/index.php";
$bestand = mapnaam($pad); // $file = "usr/local/phppower/htdocs"
De functie dirname() wordt soms gebruikt in combinatie met de variabele $SCRIPT_FILENAME om het volledige pad te verkrijgen naar het script van waaruit de opdracht wordt uitgevoerd:
$map - mapnaam($SCRIPT_FILENAME);
De functie is_dir() controleert of een bestand met een bepaalde naam een map is:
bool is_dir (string bestandsnaam)
In het volgende voorbeeld wordt de directorystructuur uit Listing 7.8 gebruikt:
$ isdir = is_dir("index.html"); // Retourneert ONWAAR
$isdir = is_dir("boek"); // Geeft WAAR terug
De functie mkdir() doet hetzelfde als het UNIX-commando met dezelfde naam; het maakt een nieuwe map aan. mkdir() functiesyntaxis:
int mkdir (tekenreekspad, int-modus)
De parameter path specificeert het pad waarnaar de nieuwe map moet worden gemaakt. Vergeet niet de parameter te beëindigen met de naam van de nieuwe map! De modusparameter bepaalt de machtigingen die aan de gemaakte map zijn toegewezen.
Net zoals de functie fopen() een manipulator opent om met een bepaald bestand te werken, opent de functie opendir() een manipulator om met een map te werken. De syntaxis van de functie opendir() is:
int opendir (tekenreekspad)
De functie closedir() sluit de directory-handle die als parameter is doorgegeven. De syntaxis van de functie closedir() is:
void closedir(int directory_manipulator)
De functie readdir() retourneert het volgende element van de opgegeven map. Syntaxis:
string leesmap(int directory_manipulator)
Met deze functie kunt u eenvoudig alle bestanden en submappen weergeven die zich in de huidige map bevinden:
$dh = openmap(" .);
while ($bestand = leesmap($dh)) :
druk "$bestand
"; eindtijd;
De functie chdir() werkt net als het UNIX cd-commando; het verandert naar de map die door de parameter is opgegeven. syntaxis van de functie chdir():
int chdir (reeksmap)
In het volgende voorbeeld navigeren we naar het boek/submap en drukken de inhoud ervan af:
$nieuwe map = "boek";
chdir($newdir) or die("Kan niet naar map wijzigen ($newdir)"); $dh = openmap(" . ");
while ($bestand = leesmap($dh)) ;
druk "$bestand
";
De functie rewlndir() verplaatst de huidige positieaanwijzer naar het begin van de map die wordt geopend door de functie opendir(). De syntaxis van de functie rewinddir() is:
ongeldige terugspoelmap (int directory_manipulator)
Project 1: Eenvoudige trefferteller
Het script dat in deze sectie wordt gepresenteerd, telt het aantal hits op de pagina waarop het zich bevindt. Voordat u verdergaat met de code in Listing 7.9, bekijkt u het algoritme dat in pseudocode is geschreven:
- Wijs aan de variabele $access de naam toe van het bestand waarin de tellerwaarde wordt opgeslagen.
- Gebruik de functie file() om de inhoud van $access in de array $visits te lezen. Het voorvoegsel @ vóór de functienaam onderdrukt mogelijke fouten (er is bijvoorbeeld geen bestand met de opgegeven naam).
- Stel de variabele $current_visitors in op de waarde van het eerste (en enige) element van de array $visits.
- Verhoog de waarde van $current_visitors met 1.
- Open het $access-bestand om te schrijven en stel de huidige positieaanwijzer in op het begin van het bestand.
- Schrijf de waarde $current_visitors naar het bestand $access.
- Sluit de manipulator die verwijst naar het $access-bestand.
Lijst 7.9. Simpele trefferteller
// Script: eenvoudige hitteller
// Doel: het aantal hits in een bestand opslaan
$access = "hits.txt"; // De bestandsnaam wordt willekeurig gekozen
$current_visitors = $bezoeken; // Haal het eerste (en enige) element op
+$huidige_bezoekers; // Verhoog de trefferteller
$fh = fopen($toegang. "w"); // Open het bestand hits.txt en installeer
// verwijzing naar de huidige positie aan het begin van het bestand
@fwrite($fh, $current_visitors);// Schrijf een nieuwe tellerwaarde
// naar het bestand "hits.txt"
fsluiten($fh); // Sluit de bestandsmanipulator "hits.txt"
Project 2: een plattegrond maken
Het script in Listing 7.10 bouwt een sitemap, een hiërarchische weergave van alle mappen en bestanden op de server, beginnend bij een bepaalde map. Bij het berekenen van de opvulling van de elementen waaruit een sitemap bestaat, worden de functies gebruikt die in dit en voorgaande hoofdstukken zijn gedefinieerd. Voordat u verdergaat met het programma, bekijkt u het algoritme dat in pseudocode is geschreven:
- Declareer servicevariabelen om de bovenliggende map, de naam van het grafische bestand met de afbeelding van de map, de paginanaam en de vlag van het serverbesturingssysteem (Windows of een ander systeem) op te slaan.
- Declareer een display_directory()-functie die de inhoud van een map leest en deze opmaakt voor weergave in de browser.
- Construeer het mappad door de naam die is doorgegeven in de variabele $dir1 te combineren met $dir.
- Open een map en lees de inhoud ervan. Formatteer map- en bestandsnamen en geef ze weer in de browser.
- Als het huidige bestand een map is, roep dan display_di rectory() recursief aan en geef de naam door van de nieuwe map die moet worden weergegeven. Bereken de inspringing die wordt gebruikt bij het opmaken van de uitvoer.
Als het bestand geen map is, wordt het geformatteerd om als hyperlink te worden weergegeven (en wordt ook de inspringing die bij de opmaak wordt gebruikt berekend).
Lijst 7.10. Sitemap.php-programma
// Bestand: sitemap.php
// Doel: het maken van een sitemap
// Directory van waaruit de kaartconstructie begint
$beg_path = "C:\Program FilesVApache Group\Apache\htdocs\phprecipes";
// Bestand met een grafische afbeelding van de map.
// Het pad moet relatief* zijn ten opzichte van de hoofdmap van de Apache-server
$folder_location = "C:\Mijn documenten\PHP voor programmeurs\FINAL CHPS\graphics\folder.gif";
// Tekst in de venstertitel $page_name = "PHPRecipes SiteMap";
// Op welk systeem wordt het script gebruikt: Linux of Windows?
// (0 - Windows; 1 - Linux)
$gebruikjinux = 0;
// Functie: display_directory
// Doel: het lezen van de inhoud van de map gespecificeerd door de parameter
// $dir1, gevolgd door het formatteren van de map- en bestandshiërarchie.
// De functie kan recursief worden aangeroepen.
functie display_directory ($dir1, $map_locatie, $using_linux, $init_diepte) (
// Updatepad
Sdh = openmap($map);
while($file = leesmap($dh)) :
// Directory-elementen "." en ".." worden niet weergegeven.
if (($bestand != ".") && ($bestand != "..")) :
if ($using_linux == 0):
$diepte = explode("\\", $dir): else:
$diepte = explode("/", $dir); eindif ; $huidige_diepte = groottevan($diepte);
// Bouw het pad volgens de regels van het gebruikte besturingssysteem. if ($using_linux == 0):
$tab_diepte = $huidige_deptn - $init_diepte;
$bestand = $map. "\\", $bestand; anders:
$bestand = $map. "/",$bestand; eindals;
// Bevat $file een map? if (is map($file)):
// Bereken de inspringing
terwijl ($x< ($tab_depth * 2)) :
$x++; eindtijd;
afdrukken "
".basisnaam($bestand)."
";
// Verhoog de teller
// Recursieve aanroep naar display_directory()
display_directory($bestand, $map_locatie, $using_linux, $init_diepte);
// Geen map
// Bouw een pad volgens de regels van het gebruikte
// besturingssysteem.
if ($using_linux == 0):
$tab_diepte = ($huidige_diepte - $init_diepte) - 2; $x = 0;
// Bereken de inspringing
terwijl ($x< (($tab_depth * 2) + 5)) :
afdrukken " ".basisnaam($bestand)."
";
afdrukken " ".basisnaam($bestand)."
";
eindals; // Is_dir(bestand) endif: // If ! "." of ".."
// Sluit de map closedir($dh);
// Bereken de initiële opvulling
if ($using_linux == 0):
$diepte = explode("\\", $beg_path);
$diepte = explode("/", $beg_path);
$init_diepte = groottevan($diepte);
display_directory($beg_path, $folder_location, $using_linux, $init_ depth);
In afb. Figuur 7.1 toont het resultaat van het uitvoeren van het script voor een map met verschillende hoofdstukken van dit boek.
Rijst. 7.1. Weergave van de directorystructuur op de server met behulp van het sitemap.php-script
Resultaten
In dit hoofdstuk werden veel PHP-tools voor het werken met bestanden geïntroduceerd. In het bijzonder hebben wij de volgende kwesties overwogen:
- het controleren van het bestaan van bestanden;
- bestanden en I/O-streams openen en sluiten;
- schrijven naar en lezen uit een bestand;
- het bestand omleiden naar de uitvoerstroom;
- het lanceren van externe programma's;
- bestandssysteembewerkingen.
Het materiaal in dit hoofdstuk vormt de basis voor het volgende hoofdstuk, 'Strings en reguliere expressies', omdat bij het ontwikkelen van webapplicaties stringverwerking en I/O-bewerkingen zeer nauw met elkaar verbonden zijn.
Elke programmeur moet correct met bestanden kunnen werken. Dit artikel is bedoeld voor beginnende PHP-programmeurs, maar de “verzameling recepten” zal ook nuttig zijn voor gevorderde gebruikers.
Het werken met bestanden is onderverdeeld in 3 fasen:
- Een bestand openen.
- Gegevensmanipulatie.
- Het bestand sluiten.
I. Een bestand openen
Om een bestand in de PHP-omgeving te openen, gebruikt u de functie fopen(). De vereiste parameters voor deze functie zijn de bestandsnaam en de bestandsmodus.
$fp = fopen("counter.txt", "r");
Volgens de PHP-documentatie worden de volgende soorten bestandsmodi onderscheiden:
- r – open het bestand voor alleen-lezen.
- r+ - opent een bestand om tegelijkertijd te lezen en te schrijven.
- w – maakt een nieuw leeg bestand. Als een dergelijk bestand al bestaat op het moment van de oproep, wordt het vernietigd.
- w+ - vergelijkbaar met r+, alleen als een dergelijk bestand bestaat op het moment van aanroepen, wordt de inhoud ervan verwijderd.
- a – opent een bestaand bestand in de schrijfmodus, waarbij de aanwijzer naar de laatste byte van het bestand (naar het einde van het bestand) wordt verplaatst.
- a+ - opent een bestand in de lees-schrijfmodus, waarbij de aanwijzer naar de laatste byte van het bestand (naar het einde van het bestand) wordt verplaatst. De inhoud van het bestand wordt niet verwijderd.
Opmerking: Er kan nog één optionele parameter aan het einde van een van de regels staan: b of t . Als b is opgegeven, wordt het bestand geopend in de binaire lees-/schrijfmodus. Als t, dan wordt de regelinvoervertaalmodus voor het bestand ingesteld, d.w.z. het wordt gezien als tekstueel.
Om dit aan te tonen, kunt u het volgende scenario overwegen:
//Opent een bestand in verschillende modi
$fp = fopen("counter.txt", "r"); // Binaire modus
$fp = fopen("counter.txt", "rt"); // Tekstmodus
$fp = fopen("http://www.yandex.ru", "r");// Opent een HTTP-verbinding voor lezen
$fp = fopen("ftp://gebruiker: [e-mailadres beveiligd]", "w"); //Open een FTP-verbinding met vermelding van de login en het wachtwoord
?>
II. Manipulatie van bestandsgegevens
U kunt gegevens naar een bestand schrijven met behulp van PHP met behulp van de functie fschrijven(). Deze functie heeft 2 vereiste parameters en 1 optionele parameter nodig. De vereiste parameters zijn de bestandsdescriptor en de bestandsmodus:
$fp = fopen("counter.txt", "a"); // Open het bestand in de schrijfmodus
$mytext = "We moeten deze regel schrijven\r\n"; // Brontekenreeks
$test = fwrite($fp, $mijntekst); // Schrijf naar bestand
if ($test) echo "De gegevens zijn succesvol in het bestand ingevoerd.";
else echo "Fout bij schrijven naar bestand.";
fsluiten($fp); //Sluit het bestand
?>
Gebruik de functie om een bestand regel voor regel te lezen fgets(). De functie heeft twee vereiste parameters nodig:
als ($fp)
{
terwijl (!feof($fp))
{
$mijntekst = fgets($fp, 999);
echo $mijntekst."
";
}
}
fsluiten($fp);
?>
Opmerking: In dit voorbeeld specificeert de waarde 999 het aantal tekens dat wordt gelezen totdat de aanwijzer het einde van het bestand (EOF) bereikt.
Om het bestand als één geheel te lezen, moet u de functie gebruiken leesbestand(), waarvoor 1 vereiste parameter nodig is. De functie opent een bestand, geeft de inhoud ervan weer in een browservenster en sluit het bestand vervolgens:
echoreadfile("counter.txt");
?>
U kunt ook de functie fpassthru() gebruiken, waarvoor 1 vereiste parameter nodig is. Voordat u deze functie gebruikt, moet u het bestand in de leesmodus openen. Wanneer het bestand klaar is met lezen, sluit de functie het bestand automatisch (en wordt de bestandsdescriptor ongeldig).
$fp = fopen("counter.txt", "r"); // Open het bestand in leesmodus
if ($fp) echo fpassthru($fp);
elsecho "Fout bij openen bestand";
?>
Heel vaak zijn er situaties waarin het nodig is om de inhoud van een site in een array te lezen. Deze functie omvat het gebruik van de functie bestand(). Wanneer deze functie wordt aangeroepen, wordt elke regel van het bestand opgeslagen in een afzonderlijk element van de opgegeven array.
Opmerking: De functie mag niet worden gebruikt bestand() naar binaire bestanden (binair-veilig), omdat Het is niet veilig als het gaat om het lezen van binaire bestanden, en als het ergens een end-of-file (EOF)-teken tegenkomt, garandeert dit niet dat u het volledige binaire bestand zult lezen.
$file_array = bestand("counter.txt"); // Lees het bestand in de $file_array
// Werken met arraygegevens
?>
Opmerking: het werken met arrays wordt in detail beschreven, auteurs: Mukhametshin D.F., Simdyanov I.V.
Aan het einde van het artikel vindt u een goed "receptenboek" over arrays, dat oplossingen biedt voor veel problemen waarmee een webprogrammeur dagelijks te maken krijgt.
Laten we ons een situatie voorstellen waarin een bestand karakter voor karakter moet worden gelezen. Om dit te doen kunnen we de functie gebruiken fgetc(). De functie heeft één parameter nodig. De functie is handig als we een teken of het aantal identieke tekens moeten vinden.
$fp = fopen("counter.txt", "r"); // Open het bestand in leesmodus
als ($fp)
{
terwijl(!feof($fp))
{
$char = fgetc($fp);
if ($char == "c") $i = $i + 1;// Zoek het teken "c"
}
echo "Aantal 'c'-letters in bestand: ". $ik;
}
else echo "Fout bij openen bestand";
?>
III. Een bestand sluiten
Het bestand wordt gesloten met de functie fsluiten(), waarvoor 1 vereiste parameter nodig is.
$fp = fopen("counter.txt", "r");
als ($fp)
{
echo "Het bestand is geopend";
fsluiten($fp); // Het bestand sluiten
}
?>
Verzameling recepten
1) We moeten controleren of dit of dat bestand bestaat. Om dit te doen zullen we de functie gebruiken file_exists().
mijnbestand("counter.txt"); // Gebruik de functie mijnbestand, waarbij u de bestandsnaam als argument doorgeeft
function myfile($name) //Maak een functie om het bestaan van een bestand te controleren
{
if (file_exists($name)) echo "Het bestand bestaat";
}
?>
Opmerking: Functie bestand_bestaat controleert geen bestanden op de externe webserver. Om de functie correct te laten werken, moet het bestand met het script zich op dezelfde server bevinden als het bestand dat wordt gecontroleerd.
2) Bepaal de bestandsgrootte met behulp van de functie bestandsgrootte()
mijnbestand("counter.txt");
function myfile($name) //Maak een functie om het bestaan van een bestand te controleren en de bestandsgrootte te bepalen
{
if (file_exists($name)) echo "Bestandsgrootte: ".filesize($name)." bytes";
anders echo "Bestand bestaat niet";
}
?>
3) Maak een tijdelijk bestand met behulp van de functie tmpbestand()
$mijnbestand = tmpbestand();
fwrite($myfile, "Deze regel wordt naar een tijdelijk bestand geschreven."); // Schrijf naar een tijdelijk bestand
fseek($mijnbestand, 0); // Stel de bestandsaanwijzer in
echo fread($mijnbestand, 1024); // voer de inhoud van het bestand uit
?>
4) U moet het aantal regels in het bestand bepalen. Hiervoor gebruiken we de functie graaf()
$fp = bestand("counter.txt");
echo "Aantal regels in bestand: ".count($fp);
?>
5) We moeten een gebruiken
$fp = fopen("counter.txt", "a");
kudde($fp, LOCK_EX); // Vergrendel het bestand om te schrijven
fwrite($fp, "Te schrijven regel");
kudde($fp, LOCK_UN); // Ontgrendelen
fsluiten($fp);
?>
6) We moeten een bepaalde regel uit het bestand verwijderen
$num_stroka = 5; //Verwijder regel 5 uit het bestand
$bestand = bestand("counter.txt"); // Lees het volledige bestand in een array
voor($i = 0; $i< sizeof($file); $i++)
if($i == $num_stroka) unset($bestand[$i]);
$fp = fopen("counter.txt", "w");
fputs($fp, implode("", $file));
fsluiten($fp);
?>
7) Bepalen van het bestandstype. De functie gebruiken
In feite is het openen van een php-bestand geen groot probleem. Het kan lastiger zijn om een flesje bier open te trekken als je midden in een bos staat. Maar alleen fanatieke programmeurs denken zo. En voor beginners vertellen we je over alle mogelijkheden van PHP voor het werken met bestanden:
php-bestanden
Bestanden met de php-extensie bevatten code die is geschreven in de gelijknamige programmeertaal. In tegenstelling tot andere talen is PHP een programmeertaal aan de serverzijde. Dat wil zeggen, het draait aan de serverzijde. Om de code te kunnen debuggen, moet er daarom een lokale server op de clientcomputer worden geïnstalleerd.
Om met php-bestanden te werken, worden speciale applicaties gebruikt: software-editors. De meest voorkomende zijn:
- Droomwever.
- PHPBewerken.
- Eclipse PHP-ontwikkeling.
Wanneer u websites maakt op basis van PHP, moet u mogelijk programmacode hergebruiken. In dergelijke situaties is het handig om kant-en-klare oplossingen in een ander bestand aan te sluiten. Hiervoor wordt het include-construct gebruikt. De syntaxis is:
bestandsnaam bevatten
Aansluitvoorbeeld:
Inbegrepen bestand:
Het toevoegen van een bestand is ook mogelijk met behulp van de require-constructie. In tegenstelling tot include bevat het het bestand voordat de programmacode wordt uitgevoerd. Als u require in de code gebruikt, is slechts één aanroep naar dit bestand mogelijk. Wanneer het systeem opnieuw wordt benaderd, wordt er een algemene foutmelding weergegeven en wordt de uitvoering van het programma stopgezet.
De include-constructie omvat alleen de broncode tijdens de uitvoering van het programma. Het ondersteunt meerdere lezingen van het PHP-bestand. Als er een fout optreedt, wordt alleen een waarschuwingsbericht weergegeven en wordt de uitvoering van de code voortgezet vanaf de volgende regel.
Bestanden openen en sluiten
In php worden alle bewerkingen met bestanden in verschillende fasen uitgevoerd:
- Een bestand openen;
- Inhoud redigeren;
- Het bestand sluiten.
De functie fopen() wordt gebruikt om een bestand te openen. De syntaxis is:
int fopen(string bestandsnaam, stringmodus [, int use_include_path])
Geaccepteerde argumenten:
- string bestandsnaam – bestandsnaam of absoluut pad ernaartoe. Als het pad naar het bestand niet is opgegeven, wordt er in de huidige map gezocht. Als het bestand dat u zoekt ontbreekt, geeft het systeem een foutmelding. Voorbeeld:
- stringmodus – geeft de bestandsopeningsmodus aan. Waarden geaccepteerd door het argument:
- r – het bestand wordt alleen geopend om te lezen, de bestandsaanwijzer wordt aan het begin geplaatst;
- r+ – bestand is geopend voor lezen en schrijven;
- w – maakt een nieuw bestand aan dat alleen bedoeld is om te schrijven. Als er al een bestand met dezelfde naam bestaat, worden alle gegevens daarin automatisch verwijderd;
- w+ - maakt een nieuw bestand aan voor schrijven en lezen. Als zo'n bestand bestaat, worden de gegevens ervan volledig overschreven door nieuwe;
- a – het bestand is open voor schrijven. De wijzer wordt aan het einde geplaatst. Dat wil zeggen dat het schrijven naar het php-bestand niet vanaf het begin begint, maar vanaf het einde;
- a+ – open een bestand in de lees-schrijfmodus. De opname begint vanaf het einde;
- b – manier van werken met een bestand dat binaire gegevens bevat (in het binaire getalsysteem). Deze modus is alleen beschikbaar op het Windows-besturingssysteem.
Om de toegang tot een bestand te sluiten, gebruikt u de functie fclose(). Syntaxis:
int fclose (int file) , waarbij int file een handvat is voor de site die moet worden gesloten.
Na elke lees- of schrijfactie moet het bestand met deze functie worden gesloten. Anders blijft de stream die voor het bestand is gemaakt open. En dit leidt tot onnodig verbruik van servercapaciteit.
Voorbeeld:
Bestanden lezen en schrijven
Om eenvoudig de volledige inhoud van een bestand weer te geven, is de functie readfile() ideaal. De syntaxis is:
readfile (string bestandsnaam), waarbij string bestandsnaam de naam van het stringbestand is (geen handle).
int fpassthru (int-bestand)
De functie vereist het openen en sluiten van een bestand. Voorbeeld:
Het resultaat is vergelijkbaar met het vorige.
Met functies voor het werken met bestanden in php kunt u de inhoud regel voor regel en teken voor teken lezen:
- string fgets (int-bestand, int-lengte)– de functie leest een string met lengte lengte . Voorbeeld:
- string fread (int-bestand, int-lengte)– de actie is identiek aan de vorige.
Om tekstgegevens naar een bestand te schrijven, zijn er twee identieke functies:
- int fputs (int-bestand, string string [, int lengte ])
- int fwrite(int-bestand, string string [, int lengte ])
De functies schrijven naar een bestand int file een string string met de opgegeven lengte int lengte ( optioneel argument). Voorbeeld:
Bestanden maken en verwijderen
Om een php-bestand te maken, kunt u de functie fopen() gebruiken in de toegangsmodus "w" of "w+". Of de touch()-functie. Het stelt de wijzigingstijd van het bestand in. Als er geen element is met de gezochte naam, wordt het aangemaakt. De syntaxis is:
int touch (tekenreeks bestandsnaam [, int tijd [, int atime]])
Gebruik de functie copy() om een kopie van een bestand te maken. Als argumenten worden de naam van het origineel en het bestand waarnaar de inhoud moet worden gekopieerd, gebruikt. Als het niet bestaat, wordt het gemaakt. Functiesyntaxis:
int kopie(tekenreeksbestand1, tekenreeksbestand2)
U kunt een bestand verwijderen met de functie unlink(). De syntaxis ervan.
Onder werken met bestanden in PHP impliciet uit bestand lezen En naar bestand schrijven diverse informatie. Het is duidelijk dat je veel met bestanden moet werken, dus welke dan ook PHP-programmeur moet kunnen uit bestand lezen En naar bestand schrijven.
Vervolg werken met bestanden in PHP zoals dit:
- Bestand openen.
- Voer de nodige acties uit.
- Sluit het bestand.
Zoals u kunt zien, lijkt de volgorde van het werken met bestanden op het werken met bestanden via een gewone verkenner. Alleen hier wordt al het werk automatisch door onszelf gedaan PHP-script.
Laten we beginnen met het eerste punt: het bestand openen. Het bestand wordt geopend met fopen()-functies. De eerste parameter is het bestandspad en de tweede parameter is modificator. Laten we meteen kijken naar de mogelijke modifiers:
- A- opent het bestand alleen om te schrijven, waarbij de aanwijzer aan het einde van het bestand wordt geplaatst.
- een+ A, maar het bestand wordt ook geopend om te lezen.
- R- opent het bestand voor alleen-lezen en de aanwijzer wordt naar het begin van het bestand geplaatst.
- r+- hetzelfde als modificator R, maar het bestand wordt ook geopend om te schrijven.
- w- opent het bestand alleen om te schrijven, zet de aanwijzer op het begin van het bestand en wist de volledige inhoud van het bestand.
- w+- hetzelfde als modificator w, alleen het bestand wordt ook geopend om te lezen.
Er zijn ook twee manieren om met bestanden te werken: binair(aangeduid B) En tekst(aangeduid T). Als u met een gewoon tekstbestand werkt, selecteert u de tekstmodus en als u bijvoorbeeld met een afbeelding werkt, selecteert u de binaire modus.
Dit zijn allemaal basismodificatoren, die voldoende voor u zullen zijn. Laten we nu leren hoe we een bestand kunnen sluiten. Sluit het bestand met fclose() functies.
Laten we nu verder gaan met het lezen van het bestand met behulp van fread() functies. En laat ik tot slot een voorbeeld geven:
$inhoud = "";
terwijl (!feof($handle))
$inhoud .= fread($handle, 4096);
fclose($handle);
?>
In dit voorbeeld openen we het bestand eerst om te lezen in de tekstmodus (modifier rt). fopen() functie retourneert de zogenaamde beschrijving, waarmee u met het bestand kunt communiceren en naar een variabele kunt schrijven hendel. Dan zitten we in een cirkel terwijl() totdat het einde van het bestand is bereikt, lezen we elke keer de inhoud 4096 tekens die we naar de variabele schrijven inhoud. Nadat het leesproces is voltooid, sluit u het bestand, opnieuw met behulp van de bestandsdescriptor.
Laten we nu verder gaan met opnemen met fwrite() functies:
$handle = fopen("files/a.txt", "at");
$string = "Dit is tekst";
fwrite($handle, $string);
fclose($handle);
?>
Nadat u dit script hebt uitgevoerd, in het bestand a.txt de regel " wordt toegevoegd Dit is tekst".
Bijzonder aandachtige lezers hebben aandacht besteed aan de aanwijzingen waarover ik zojuist hierboven schreef. Wijzer- dit is de huidige positie van de denkbeeldige "cursor" in het bestand. Dit is waar het werken met het bestand begint. U kunt de positie van de aanwijzer wijzigen met fseek()-functies:
$handle = fopen("bestanden/a.txt", "rt");
echo $inhoud."
";
fseek($handle, 0, SEEK_SET);
$inhoud = fread($handle, 3);
echo $inhoud."
";
?>
Wij lezen dus eerst 3 teken (als resultaat wordt de huidige aanwijzerpositie verschoven met 3 posities). Vervolgens plaatsen we een verwijzing naar het begin van het bestand. En wij lezen opnieuw 3 symbool. Zoals je misschien al geraden had, telden we hetzelfde twee keer. Dat is de eerste keer 3 symbool, ging toen terug en telde opnieuw 3 symbool. Ook als jij fseek()-functies vervangen ZOEK_SET op SEEK_CUR, dan zal de tweede parameter de aanwijzerpositie niet instellen, maar deze verschuiven ten opzichte van de huidige locatie. Ik raad je zelfs aan om met aanwijzingen te oefenen, omdat het niet zo gemakkelijk te begrijpen is. Ik raad ook aan om iets naar het bestand te schrijven op de pointerpositie, bijvoorbeeld helemaal aan het begin van het bestand. En zorg ervoor dat u uw resultaten toelicht.
En tot slot zou ik nog een paar functies willen geven waarmee je op het eenvoudigste niveau met bestanden kunt werken: file_put_content() En file_get_contents(). Functie file_put_contents() schrijft naar een bestand, en de functie file_get_contents() leest inhoud uit een bestand. Deze functies zijn heel gemakkelijk te gebruiken, maar er zijn minder opties (hoewel ze in de regel niet nodig zijn):
file_put_contents("files/a.txt", "Dit is tekst 2");
echo file_get_contents("files/a.txt");
?>
In dit script schreven we eerst de regel " Dit is tekst 2" naar een bestand, en dan lezen we de resulterende inhoud en voeren deze uit. Zoals u kunt zien, is het moeilijk om een eenvoudiger manier te bedenken uit bestand lezen En naar bestand schrijven.
Dat zijn alle hoofdpunten werken met bestanden in PHP.
En nu komt er een vrij grote, maar niet ingewikkelde les over het werken met bestanden in PHP. Allereerst: waar zijn de bestanden voor? Je kunt immers alles opslaan in een MySQL of PostgreSQL of welke andere database dan ook. Maar soms zijn er taken waarbij het gebruik van een database, waarbij alle verwerking en zorg voor verbindingsbeveiliging, niet aan te raden is. We moeten bijvoorbeeld een reguliere teller maken, maar daarvoor gebruikten we geen database in het project. Moeten we, ter wille van één kleine teller, een database maken en daarin slechts een paar regels opslaan? Het is veel eenvoudiger om hier bestanden te gebruiken. Bovendien ondersteunt de hosting soms helemaal geen databases, dan zijn bestanden over het algemeen de enige optie.
Laten we zeggen dat ik je ervan heb overtuigd dat de bestanden nodig zijn :) Laten we nu eens kijken hoe we ermee kunnen werken. Hoe u kunt maken, openen, schrijven, overschrijven, lezen enzovoort. Eerste dingen eerst.
Maak een bestand
PHP gebruikt de fopen-functie om bestanden te openen. Het kan echter ook bestanden maken. Als u een bestandsnaam doorgeeft die niet bestaat, wordt deze aangemaakt.
De fopen-functie zelf heeft twee parameters nodig, die beide vereist zijn. Eerst moeten we de naam opgeven van het bestand dat we willen openen. Ten tweede geeft u een parameter door die aan de functie uitlegt wat we met dit bestand willen doen (bijvoorbeeld uit het bestand lezen, schrijven, enz.).
Als we een bestand moeten maken, specificeren we de naam ervan en geven we de parameter door waarmee we gegevens willen schrijven. Opmerking: we moeten PHP zeker vertellen wat we naar het bestand schrijven, anders wordt er geen nieuw bestand gemaakt.
Voorbeeld:
$ourFileName = "testbestand.txt";
$ourFileHandle = fopen($ourFileName, "w") or die("kan bestand niet openen");
fclose($ourFileHandle);
De eerste regel $ourFileName = testFile.txt maakt een stringvariabele aan waarin we de bestandsnaam opslaan.
De tweede regel $ourFileHandle = fopen($ourFileName, 'w') of die("can't open file") creëert of opent respectievelijk een bestaand bestand om te schrijven. Of er wordt een bericht geretourneerd dat het bestand niet kan worden geopend.
De derde regel fclose($ourFileHandle) sluit het bestand. Het is eigenlijk eenvoudig.
Opties voor het openen van bestanden in php
De eerste parameter 'r' (lezen) - opent het bestand voor alleen-lezen; u kunt er niet naar schrijven.
De tweede parameter ‘w’ (schrijven) – wordt geopend voor schrijven. In dit geval begint de opname altijd vanaf het begin van het bestand. Als er al informatie aanwezig is, wordt deze overschreven.
De derde parameter 'a' (toevoegen) - opent het bestand om te schrijven, maar wordt toegevoegd aan het einde van het bestand, in tegenstelling tot w.
Geavanceerde opties:
Parameter 'r+' - opent voor zowel lezen als schrijven. De aanwijzer bevindt zich aan het begin van het bestand.
Parameter 'w+' - opent voor zowel lezen als schrijven, MAAR verwijdert alle informatie die in het bestand stond!!!
parameter 'a+' - wordt geopend voor lezen en schrijven, maar de aanwijzer bevindt zich aan het einde van het bestand.
Uiteraard kan slechts één van deze parameters aan een functie worden doorgegeven, en niet meerdere. Ze moeten worden vervangen door 'X':
fopen($onzeBestandsnaam, "X")
Naar bestand schrijven
Welnu, nu hebben we het bestand geopend en de parameter geselecteerd die we nodig hebben, wat nu? Je moet er iets in schrijven. Hoe dit te doen? Met behulp van de fwrite-functie, die als parameters een verwijzing naar een bestand en een regel tekst gebruikt die we willen schrijven. Voorbeeld:
$mijnBestand = "testBestand.txt";
$fh = fopen($myFile, "w") or die("kan bestand niet openen");
$stringData = "Eerste regel";
fwrite($fh, $stringData);
$stringData = "Tweede regel";
fwrite($fh, $stringData);
We hebben een bestand testFile.txt gemaakt, de verwijzing ernaar wordt opgeslagen in de $fn-variabele. We schreven er de regel ‘Eerste regel’ in (aan het einde gebruikten we het eindelijnsymbool n) en vervolgens ‘Tweede regel’. Vervolgens hebben ze het dossier gesloten.
AANDACHT! Vergeet nooit uw bestanden te sluiten! Anders worden de gegevens in de bestanden niet opgeslagen als de uitvoering van het script abnormaal wordt beëindigd! Gebruik altijd fclose na het werk!!!
Lezen uit een bestand
We hebben het opgeschreven, laten we het nu lezen! Het is ook niet zo moeilijk. We gebruiken de fread-functie. Als invoer geven we het een verwijzing naar het bestand en het aantal bytes dat we willen lezen. Eén teken is bijvoorbeeld gelijk aan één byte (afhankelijk van de codering). We willen 5 tekens lezen: $theData = fread($fh, 5).
Maar als we alle informatie in het bestand moeten krijgen, dan hebben we de filesize-functie nodig, die het aantal bytes in het bestand retourneert. Als het resultaat van de filesize-functie wordt doorgegeven aan fread, dan krijgen we alle informatie uit het bestand:
$mijnBestand = "testBestand.txt";
$fh = fopen($mijnBestand, "r");
$theData = fread($fh, bestandsgrootte($mijnbestand));
Ik hoop dat ik het duidelijk heb uitgelegd.
$mijnBestand = "testBestand.txt";
$fh = fopen($mijnBestand, "r");
$deData = fgets($fh);
Als resultaat krijgen we de eerste regel uit het bestand testFile.txt. Om alle regels te doorlopen, moet je dus een foreach-lus gebruiken:
$lines = file("testFile.txt");
foreach($regels als $single_line)
echo $single_line . "
N";
Nu heb je geleerd hoe je bestanden kunt openen om te lezen, schrijven of beide. Schrijf er gegevens naar of voeg ze bovenaan toe met Append, en lees er ook informatie uit.
