Share
In deze Tutorial Tuts + Premium leren we hoe je met bestandsbewerkingen werkt met behulp van PHP. Dit is een van de meest fundamentele onderwerpen van server side programming in het algemeen. Bestanden worden gebruikt in webapplicaties van alle groottes. Laten we dus leren lezen, schrijven, maken, verplaatsen, kopiëren, verwijderen van bestanden en meer.
We gaan eerst leren met deze bewerkingen, omdat het heel eenvoudige one-liners zijn en ze niet te maken hebben met bestandsaanwijzingen..
$ file = "test.txt"; $ new_file = "test_copy.txt"; kopiëren ($ bestand, $ nieuwbestand);
$ file = "test.txt"; $ new_file = "test_copy.txt"; hernoemen ($ bestand, $ nieuwbestand);
Merk op dat de functie "hernoemen" en niet "verplaatsen" wordt genoemd. Intern is het hernoemen van een bestand hetzelfde als het verplaatsen naar een nieuwe locatie.
Dezelfde code werkt bij het wijzigen van de map van het bestand:
$ file = "test.txt"; $ new_file = "anders / map / test_copy.txt"; hernoemen ($ bestand, $ nieuwbestand);
Er is geen functie als "verwijderen". Hier noemen we de functie "ontkoppelen".
$ file = "test.txt"; ontkoppelen ($ bestand, $ nieuwbestand);
Nu is het tijd om enkele bestandsaanwijzingen te behandelen. Er is meer dan één manier om de inhoud van een bestand in PHP te lezen, maar we beginnen eerst met de meest basismethode. Later in het artikel zullen we meer te weten komen over de alternatieve methoden.
Er zijn drie bestandsfuncties die we hier zullen gebruiken: fopen, fread en fclose.
$ file = "test.txt"; // open het bestand $ fp = fopen ($ file, "r"); // lees 5k data uit het bestand $ contents = fread ($ fp, 5000); // sluit het bestand fclose ($ fp);
Bij het openen van het bestand nemen we een tweede parameter op, die het type toegang bepaalt. In dit geval staat "r" voor "alleen lezen". Er zijn andere typen die we moeten gebruiken voor schrijven en toevoegen die we verderop in het artikel zullen behandelen.
Het tweede belangrijke aandachtspunt is de tweede parameter in de fread-functie. Dit bepaalt de lengte van de gegevens (in bytes) om uit het bestand te lezen. Om de volledige inhoud van het bestand te lezen, moeten we de totale bestandsgrootte doorgeven. De functie bestandsgrootte doet het volgende:
$ file = "test.txt"; // open het bestand $ fp = fopen ($ file, "r"); // lees 5k data uit het bestand $ contents = fread ($ fp, filesize ($ file)); // sluit het bestand fclose ($ fp);
Sinds we met bestandswijzers zijn gaan werken, nemen we even de tijd om ze beter te begrijpen.
Een bestandsaanwijzer, ook wel "handle" genoemd, is een variabele die naar een bestand verwijst. De exacte waarde van deze variabele is niet belangrijk; alles wat we moeten weten is dat het naar een specifiek bestand verwijst. De aanwijzer wordt meestal verkregen door een bestand te openen. In PHP gebruiken we de fopen-functie.
Hoewel PHP een uitstekende garbage collector heeft die alle open bestandspunten afsluit aan het einde van een scripts-uitvoering, wordt het als een goede gewoonte beschouwd om ze handmatig te sluiten met behulp van de fclose-functie.
$ fp = fopen ($ bestand, 'r'); // ... // sluit bestanden altijd fclose ($ fp);
De bestandsaanwijzer doet eigenlijk meer dan alleen wijzen naar een bestand. Het verwijst ook naar een specifieke positie binnen dat bestand. In de meeste gevallen, wanneer u een bestand opent, wijst de bestandswijzer naar het begin (of positie 0) in dat bestand. We zullen dit concept gedetailleerder behandelen wanneer we het later over het artikel hebben over 'zoeken'.
Net als bij het lezen van bestanden, is er meer dan één manier om naar een bestand te schrijven. Eerst zullen we de basismethode zien en later in het artikel zullen we naar alternatieven kijken.
De volgende code schrijft de inhoud van de variabele $ data in het bestand test.txt.
$ file = "test.txt"; $ data = "0123456789abc"; // open het bestand voor het schrijven van $ fp = fopen ($ file, "w"); // schrijf gegevens naar het bestand fwrite ($ fp, $ data); // sluit het bestand fclose ($ fp);
Deze keer hebben we een andere vlag gebruikt om het bestand te openen. De vlag "w" opent het te schrijven bestand en overschrijft alle bestaande gegevens in het bestand. Als er iets in het bestand test.txt is, wordt dit vervangen door de tekenreeks in $ -gegevens.
De fwrite-functie was heel eenvoudig, we hebben zojuist de bestandspointer en de gegevens die naar het bestand moeten worden geschreven, doorgegeven. Er is een optionele derde parameter die de lengte van de gegevens bepaalt die moeten worden geschreven:
$ file = "test.txt"; $ data = "0123456789abc"; // open het bestand voor het schrijven van $ fp = fopen ($ file, "w"); // schrijf gegevens naar het bestand (slechts 5 bytes) fwrite ($ fp, $ data, 5); // sluit het bestand fclose ($ fp);
Als u de bovenstaande code uitvoert, is de inhoud van test.txt alleen "01234".
De bovenstaande voorbeelden werken ook voor het maken van nieuwe bestanden. Als het bestand test.txt niet bestaat, wordt het automatisch gemaakt, alleen door de fopen-functie aan te roepen.
Als u alleen een nieuw leeg bestand wilt maken zonder er gegevens in te schrijven, werkt deze code:
$ file = "does_not_exist.txt"; // maakt en opent het bestand $ fp = fopen ($ file, "w"); // sluit het bestand fclose ($ fp);
Het verplaatsen van de locatie van de bestandsaanwijzers wordt 'zoeken' genoemd. Om te zoeken kunnen we de functie fseek gebruiken, en om de positie van een gegeven pointer te krijgen, kunnen we de functie ftell gebruiken.
Voordat we zoeken gebruiken, maken we een bestand met 10 bytes aan gegevens erin.
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ bestand, "w"); fwrite ($ fp, $ data); fclose ($ fp);
Laten we nu kijken hoe deze functies zich gedragen. Hier zijn een paar verschillende voorbeelden:
$ file = "test.txt"; // opening voor lezen, wijzer moet op 0 $ fp = fopen ($ bestand, "r"); echo "open:"; // geeft 0 echo ftell ($ fp) uit. "\ n"; // ----- // zoek naar byte 4 fseek ($ fp, 4); echo "seek 4:"; // geeft 4 echo ftell ($ fp) uit. "\ n"; // ----- // je kunt grenzen overschrijden fseek ($ fp, 9000); echo "out of bounds:"; // geeft 9000 echo ftell ($ fp) uit. "\ n"; // ---- // dit is hoe je het einde bereikt fseek ($ fp, 0, SEEK_END); echo "einde:"; // geeft 10 echo ftell ($ fp) uit. "\ n"; // ---- // verplaatsen ten opzichte van de huidige positie // negatieve getallen werken fseek ($ fp, -3, SEEK_CUR); echo "ga terug met 3:"; // geeft 7 echo ftell ($ fp) door. "\ n"; // ---- // of zoek relatief aan het einde // opnieuw, negatief werkt fseek ($ fp, -3, SEEK_END); echo "ga terug vanaf 3 vanaf het einde:"; // geeft 7 echo ftell ($ fp) door. "\ n"; // ---- // doet hetzelfde als streven naar 0 terugspoelen ($ fp); echo "terugspoelen:"; // geeft 0 echo ftell ($ fp) uit. "\ n"; fclose ($ fp);
De positie van de bestandswijzer kan worden verplaatst door andere bewerkingen dan fseek.
Als u bijvoorbeeld leest, wordt de positie verplaatst:
$ file = "test.txt"; $ fp = fopen ($ bestand, "r"); // lezen van 6 bytes $ data = fread ($ fp, 6); // geeft 6 echo ftell ($ fp); fclose ($ fp);
Schrijven verplaatst het ook:
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ bestand, "w"); // schrijven van 10 bytes fwrite ($ fp, $ data); // geeft 10 echo ftell ($ fp); fclose ($ fp);
Nu we vertrouwd zijn met het lezen, schrijven en zoeken van concepten, is het tijd om de verschillende toegangsmodi voor bestanden beter te begrijpen. Bij het openen van een bestand met de fopen-functie moet de tweede parameter worden opgegeven, dit is de modus voor toegang tot bestanden. Er is een tabel in de PHP-handleiding waarin deze worden beschreven:
Door deze te bekijken, kunt u zien dat we meer opties hebben dan we tot nu toe hebben besproken. Hier zijn enkele belangrijke factoren om over na te denken over het kiezen van de juiste optie:
Er zijn veel informatie die we kunnen verkrijgen over een bestand, behalve alleen de inhoud (grootte, laatste toegangstijd, tijd wijzigen, enz ...). De belangrijkste functie die hiervoor wordt gebruikt is stat.
Het geeft de informatie terug in een array:
Accentsconagua
$ data = stat ("test.txt"); print_r ($ data); / * prints: Array ([0] => 2 [1] => 0 [2] => 33206 [3] => 1 [4] => 0 [5] => 0 [6] => 2 [7 ] => 10 [8] => 1264374556 [9] => 1264374556 [10] => 1264373231 [11] => -1 [12] => -1 [dev] => 2 [ino] => 0 [modus ] => 33206 [nlink] => 1 [uid] => 0 [gid] => 0 [rdev] => 2 [grootte] => 10 [atime] => 1264374556 [mtime] => 1264374556 [ctime] = > 1264373231 [blksize] => -1 [blocks] => -1) * / De gegevens zijn in 12 delen en worden herhaald, eerst met numerieke toetsen, en vervolgens opnieuw met stringtoetsen.
De PHP-handleiding heeft een tabel met elk ervan:
Zoals ik eerder al zei, zijn er andere alternatieve functies die kunnen worden gebruikt voor het lezen en schrijven van bestanden. Laten we er een paar bespreken.
Deze functie retourneert de volledige inhoud van een bepaald bestand. U hoeft ook helemaal geen bestandspunten te behandelen.
$ file = "test.txt"; $ contents = file_get_contents ($ bestand);
De functie accepteert nog vier extra parameters zoals beschreven in de PHP-handleiding. Als u bijvoorbeeld slechts een deel van het bestand wilt lezen, kunt u de vierde en vijfde parameter instellen:
$ file = "test.txt"; // leest 5 bytes aan gegevens, beginnend bij byte 3 $ contents = file_get_contents ($ file, NULL, NULL, 3, 5);
Ja, deze functie is eenvoudig een bestandsnaam en retourneert opnieuw de volledige inhoud van een bestand. Maar deze keer wordt de inhoud opgesplitst in een array, door het newline-teken.
Laten we een bestand maken met de volgende inhoud:
abc 123 lege regel na deze laatste regel
Gebruik nu de functie:
$ file = "test.txt"; $ contents = bestand ($ bestand); print_r ($ inhoud); / * prints Array ([0] => abc [1] => 123 [2] => lege regel hierna [3] => [4] => laatste regel) * /
Het is misschien niet voor de hand liggend, maar er is een nieuwlijnteken bij elk arrayelement. Als u ze niet wilt, kunt u ze handmatig inkorten of de vlag FILE_IGNORE_NEW_LINES gebruiken:
$ file = "test.txt"; $ contents = bestand ($ bestand, FILE_IGNORE_NEW_LINES); print_r ($ inhoud); / * prints Array ([0] => abc [1] => 123 [2] => lege regel hierna [3] => [4] => laatste regel) * /
Als u ook geen lege regels wilt, kunt u de vlag FILE_SKIP_EMPTY_LINES gebruiken:
$ file = "test.txt"; $ contents = bestand ($ bestand, FILE_SKIP_EMPTY_LINES | FILE_IGNORE_NEW_LINES); print_r ($ inhoud); / * prints Array ([0] => abc [1] => 123 [2] => lege regel hierna [3] => laatste regel) * /
Nogmaals, het is niet nodig om bestandsaanwijzingen te gebruiken. Deze functie schrijft de gegeven gegevens gewoon naar het opgegeven bestand:
$ file = "test.txt"; $ data = "0123456789"; file_put_contents ($ file, $ data);
Dit zijn alternatieven voor de stat-functie voor het verkrijgen van bestandsinformatie.
$ file = "test.txt"; // krijgt de bestandsgrootte echo-bestandsgrootte ($ bestand); // krijgt de laatste keer dat het bestand is aangepast echo filemtime ($ bestand); // krijgt de laatste keer dat het bestand toegang heeft tot echo fileatime ($ bestand);
Unix-achtige systemen hebben een vrij gedetailleerde standaard voor bestandsrechten. Windows-systemen hebben het iets eenvoudiger. Het hele onderwerp van bestandsrechten kan lang zijn en er kan een heel apart artikel op geschreven worden. Dus in plaats daarvan kijken we alleen naar twee eenvoudige concepten van bestandsrechten: "leesbaar" zijn en "beschrijfbaar" zijn.
Uw script heeft om verschillende redenen wel of niet toegang tot een bestand kunnen lezen en / of schrijven. Voordat je een bestand probeert te openen om te lezen of te schrijven, is het verstandig om te controleren of je toestemming hebt om dit te doen:
$ file = "test.txt"; if (is_readable ($ file)) // file is readable if (is_writable ($ file)) // file is writable
Om de rechten van een bestand in te stellen, gebruiken we de chmod-functie:
$ file = "test.txt"; // maakt het bestand alleen-lezen chmod ($ bestand, 0444); // maakt het bestand leesbaar en schrijfbaar chmod ($ bestand, 0666);
De bovenstaande code zou moeten werken op zowel Unix- als Windows-systemen. Het is echter mogelijk dat u de machtigingen niet kunt instellen als u niet zelf eigenaar bent van het bestand of er rechten voor hebt..
Om chmod en bestandspermissies in het algemeen beter te begrijpen, kun je deze links bekijken:
Het laatste waar we het over gaan hebben is een snelle tip voor het verwerken van grote bestanden. Dit heeft enkele implicaties voor de prestaties.
De eenvoudigste manier om een bestand te lezen en uit te voeren, is dit:
$ file = "test.txt"; echo file_get_contents ($ bestand);
Maar dat zorgt ervoor dat de volledige inhoud van het bestand in het geheugen wordt geladen. Het blijft bestaan zolang het door de websurfer wordt gedownload. Als u meerdere personen tegelijkertijd bestanden downloadt, kan dit het geheugen van uw webservers zeer snel verteren.
Een beter idee om dit aan te pakken, zou zijn om een lus te gebruiken om slechts kleine stukjes van het bestand tegelijk te lezen. Voor de lusconditie gebruiken we de feof-functie:
$ file = "test.txt"; $ fp = fopen ($ bestand, 'r'); while (! feof ($ fp)) echo fread ($ fp, 4092); fclose ($ fp);
De bovenstaande code laadt slechts 4 kb aan gegevens in het geheugen en dit zal het geheugengebruik voor grote bestandsuitgangen sterk verminderen. De feof-functie geeft true als we het einde van het bestand bereiken en dit breekt uit de hand.
