Share
I denne Tuts + Premium-opplæringen lærer vi hvordan du arbeider med filoperasjoner ved hjelp av PHP. Dette er en av de mest grunnleggende temaene for server side programmering generelt. Filer brukes i webapplikasjoner av alle størrelser. Så la oss lære å lese, skrive, lage, flytte, kopiere, slette filer og mer.
Vi skal begynne å lære med disse operasjonene først, fordi de er veldig enkle en liners, og de involverer ikke å håndtere filpekere.
$ file = "test.txt"; $ new_file = "test_copy.txt"; kopi ($ fil, $ newfile);
$ file = "test.txt"; $ new_file = "test_copy.txt"; gi nytt navn ($ file, $ newfile);
Legg merke til at funksjonen heter "endre navn" og ikke "flytte". Internt, omdøpe en fil er det samme som å flytte den til et nytt sted.
Samme kode fungerer når du endrer katalogen av filen:
$ file = "test.txt"; $ new_file = "different / folder / test_copy.txt"; gi nytt navn ($ file, $ newfile);
Det er ingen slik funksjon som "slett". Her kaller vi "unlink" -funksjonen.
$ file = "test.txt"; fjernlink ($ file, $ newfile);
Nå er det på tide å begynne å håndtere noen filpekere. Det er mer enn én måte å lese innholdet av en fil i PHP, men vi skal begynne med den mest grunnleggende metoden først. Senere i artikkelen vil vi lære om alternative metoder.
Det er tre filfunksjoner vi skal bruke her: fopen, fread og fclose.
$ file = "test.txt"; // åpne filen $ fp = fopen ($ file, "r"); // les 5k data fra filen $ content = fread ($ fp, 5000); // lukk filen fclose ($ fp);
Når du åpner filen, inkluderer vi en andre parameter, som bestemmer hvilken type tilgang. I dette tilfellet står "r" for "skrivebeskyttet". Det finnes andre typer som vi må bruke for å skrive og legge til at vi vil dekke senere i artikkelen.
Den andre viktige ting å være oppmerksom på, er den andre parameteren i fread-funksjonen. Dette bestemmer lengden på dataene (i byte) for å lese fra filen. For å lese hele innholdet i filen, må vi sende den totale filstørrelsen. Filstørrelsesfunksjonen gjør trikset:
$ file = "test.txt"; // åpne filen $ fp = fopen ($ file, "r"); // les 5k data fra filen $ content = fread ($ fp, file size ($ file)); // lukk filen fclose ($ fp);
Siden vi begynte å jobbe med filpekere, la oss ta et øyeblikk og prøve å forstå dem bedre.
En filpeker, også kjent som et filhåndtak, er en variabel som refererer til en fil. Den eksakte verdien av denne variabelen er uviktig; alt vi trenger å vite er at det peker på en bestemt fil. Pekeren oppnås vanligvis ved å åpne en fil. I PHP bruker vi fopen-funksjonen.
Selv om PHP har en utmerket søppelkollektor som lukker alle åpne filpekere på slutten av en skripteksjon, anses det som en god praksis å lukke dem manuelt ved hjelp av fclose-funksjonen.
$ fp = fopen ($ file, 'r'); // ... // lukk alltid filer fclose ($ fp);
Filpekeren gjør faktisk mer enn bare å peke på en fil. Det peker også på en bestemt posisjon i den filen. I de fleste tilfeller, når du åpner en fil, peker filpekeren til begynnelsen (eller posisjon 0) i den filen. Vi vil dekke dette konseptet mer detaljert når vi snakker om "søker" senere i artikkelen.
Akkurat som å lese filer, er det mer enn en måte å skrive til en fil. Først vil vi se den grunnleggende måten, og senere i artikkelen vil vi se på alternativer.
Følgende kode skriver innholdet i $ data-variabelen i test.txt-filen.
$ file = "test.txt"; $ data = "0123456789abc"; // åpne filen for å skrive $ fp = fopen ($ file, "w"); // skrive data til filen fwrite ($ fp, $ data); // lukk filen fclose ($ fp);
Denne gangen brukte vi et annet flagg for å åpne filen. "W" -flagget åpner filen for å skrive, og overskriver alle eksisterende data i filen. Hvis det var noe i test.txt-filen, vil den bli erstattet med strengen i $ data.
Fwrite-funksjonen var veldig enkel, vi passerte bare filpekeren og dataene som skulle skrives til filen. Det er en valgfri tredje parameter som bestemmer lengden på data som skal skrives:
$ file = "test.txt"; $ data = "0123456789abc"; // åpne filen for å skrive $ fp = fopen ($ file, "w"); // skrive data til filen (bare 5 bytes) fwrite ($ fp, $ data, 5); // lukk filen fclose ($ fp);
Hvis du kjører koden ovenfor, vil innholdet i test.txt bare være "01234".
Eksemplene ovenfor fungerer også for å lage nye filer. Hvis filen test.txt ikke eksisterer, vil den bli opprettet automatisk, bare ved hjelp av fopen-funksjonen.
Hvis alt du vil gjøre er å lage en ny tom fil uten å skrive data i den, vil denne koden fungere:
$ file = "does_not_exist.txt"; // lager og åpner filen $ fp = fopen ($ file, "w"); // lukk filen fclose ($ fp);
Handlingen med å flytte plasseringen av filpekeren kalles "søker". For å søke kan vi bruke funksjonen fseek, og for å få posisjonen til en gitt peker, kan vi bruke funksjonen ftell.
Før vi bruker søk, la oss lage en fil med 10 bytes data i den.
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ file, "w"); skriv ut ($ fp, $ data); fclose ($ fp);
La oss nå se hvordan disse funksjonene oppfører oss. Her er noen forskjellige eksempler:
$ file = "test.txt"; // åpning for lesing, pekeren skal være på 0 $ fp = fopen ($ file, "r"); ekko "åpen:"; // outputs 0 echo ftell ($ fp). "\ n"; // ----- // søke å byte 4 fseek ($ fp, 4); ekko "søk 4:"; // outputs 4 echo ftell ($ fp). "\ n"; // ----- // du kan gå ut av grensen fseek ($ fp, 9000); ekko "utenom grensene:"; // outputs 9000 echo ftell ($ fp). "\ n"; // ---- // dette er hvordan du kommer til slutten fseek ($ fp, 0, SEEK_END); ekko "ende:"; // outputs 10 echo ftell ($ fp). "\ n"; // ---- // flytte i forhold til gjeldende posisjon // negativt tall arbeid fseek ($ fp, -3, SEEK_CUR); ekko "gå tilbake med 3:"; // outputs 7 echo ftell ($ fp). "\ n"; // ---- // eller søk i forhold til slutten // igjen, negative verk fseek ($ fp, -3, SEEK_END); ekko "gå tilbake med 3 fra slutten:"; // outputs 7 echo ftell ($ fp). "\ n"; // ---- // gjør det samme som å forsøke å 0 spole tilbake ($ fp); ekko "spole tilbake:"; // outputs 0 echo ftell ($ fp). "\ n"; fclose ($ fp);
Filpekerposisjonen kan bevege seg av andre operasjoner enn fseek.
For eksempel flytter lesingen posisjonen:
$ file = "test.txt"; $ fp = fopen ($ fil, "r"); // leser 6 byte $ data = fread ($ fp, 6); // utganger 6 ekko ftell ($ fp); fclose ($ fp);
Skrive beveger også det:
$ file = "test.txt"; $ data = "0123456789"; $ fp = fopen ($ file, "w"); // skrive 10 bytes fwrite ($ fp, $ data); // outputs 10 echo ftell ($ fp); fclose ($ fp);
Nå som vi er kjent med å lese, skrive og søke konsepter, er det bedre å forstå de forskjellige filtilgangsmodene. Når du åpner en fil med fopen-funksjonen, må den andre parameteren leveres, som er filtilgangsmodus. Det er et bord i PHP-håndboken som beskriver dem:
Ved å se på disse kan du se at vi har flere alternativer enn vi snakket om så langt. Her er noen viktige faktorer å vurdere om du velger riktig alternativ:
Det er mange opplysninger du kan få om en fil i tillegg til bare innholdet (størrelse, siste tilgangstid, endringstid osv. ..) Hovedfunksjonen som brukes til dette er stat.
Den returnerer informasjonen i en matrise:
Accentsconagua
$ data = stat ("test.txt"); print_r ($ data); / * utskrifter: Array ([0] => 2 [1] => 0 [2] => 33206 [3] => 1 [4] => 0 [5] => 0 [6] => 2 [7 ] => 10 [8] => 1264374556 [10] => 1264373231 [11] => -1 [12] => -1 [dev] => 2 [ino] => 0 ] => 33206 [nlink] => 1 [uid] => 0 [gid] => 0 [rdev] => 2 [størrelse] => 10 [atime] => 1264374556 [mtime] => 1264374556 [ctime] = > 1264373231 [blksize] => -1 [blokker] => -1) * / Dataene er i 12 stykker og gjentas, først med numeriske taster, og så igjen med strengtaster.
PHP-håndboken har et bord som forklarer hver enkelt av dem:
Som nevnt tidligere er det andre alternative funksjoner som kan brukes til å lese og skrive filer. La oss gå over noen av dem.
Denne funksjonen returnerer hele innholdet i en gitt fil. Også du trenger ikke å håndtere filpekere i det hele tatt.
$ file = "test.txt"; $ content = file_get_contents ($ file);
Funksjonen aksepterer fire ytterligere parametre som beskrevet i PHP manualen. For eksempel, for å bare lese en del av filen, kan du angi fjerde og femte parameter:
$ file = "test.txt"; // leser 5 bytes data, starter ved byte 3 $ innhold = file_get_contents ($ file, NULL, NULL, 3, 5);
Ja, denne funksjonen heter bare fil, og den returnerer igjen hele innholdet i en fil. Men denne gangen er innholdet delt inn i en matrise, ved newline-tegnet.
La oss lage en fil med følgende innhold:
abc 123 tom linje etter denne siste linjen
Bruk nå funksjonen:
$ file = "test.txt"; $ content = file ($ file); print_r ($ innhold); / * utskrifter Array ([0] => abc [1] => 123 [2] => tom linje etter dette [3] => [4] => siste linje) * /
Det kan ikke være åpenbart, men det er en newline-karakter ved hvert av elementelementene. Hvis du ikke vil ha dem, kan du enten trimme dem manuelt, eller bruk FILE_IGNORE_NEW_LINES flagget:
$ file = "test.txt"; $ content = file ($ file, FILE_IGNORE_NEW_LINES); print_r ($ innhold); / * utskrifter Array ([0] => abc [1] => 123 [2] => tom linje etter dette [3] => [4] => siste linje) * /
Hvis du heller ikke vil ha de tomme linjene, kan du bruke FILE_SKIP_EMPTY_LINES flagget:
$ file = "test.txt"; $ content = file ($ fil, FILE_SKIP_EMPTY_LINES | FILE_IGNORE_NEW_LINES); print_r ($ innhold); / * utskrifter Array ([0] => abc [1] => 123 [2] => tom linje etter dette [3] => siste linje) * /
Igjen, det er ikke nødvendig å bruke filpekere. Denne funksjonen skriver bare de oppgitte dataene til den oppgitte filen:
$ file = "test.txt"; $ data = "0123456789"; file_put_contents ($ file, $ data);
Dette er alternativer til stat-funksjonen for å få filinformasjon.
$ file = "test.txt"; // får filstørrelsen ekkos størrelse ($ fil); // får siste gang filen ble endret ekkofilmtid ($ file); // får siste gang filen ble åpnet echo filatime ($ file);
Unix-lignende systemer har en ganske detaljert filtillatelser standard. Windows-systemer har det litt enklere. Hele emnet for filtillatelser kan være lang og en helt egen artikkel kan skrives på den. Så i stedet vil vi bare se på to enkle konsepter av filtillatelser: å være "lesbar" og være "skrivbar".
Skriptet ditt kan eller ikke har lese og / eller skrive tilgang til en fil på grunn av ulike årsaker. Før du prøver å åpne en fil for lesing eller skriving, er det lurt å sjekke om du har tillatelse til å gjøre det:
$ file = "test.txt"; hvis (is_readable ($ file)) // filen er lesbar hvis (is_writable ($ file)) // filen er skrivbar
For å angi tillatelsene til en fil, bruker vi chmod-funksjonen:
$ file = "test.txt"; // gjør filen skrivebeskyttet chmod ($ file, 0444); // gjør filen lesbar og skrivbar chmod ($ file, 0666);
Ovennevnte kode skal fungere på både Unix- og Windows-systemer. Du kan imidlertid ikke angi tillatelsene, hvis du ikke eier filen eller har tillatelser til det i utgangspunktet.
For bedre å forstå chmod og filtillatelser generelt, kan du sjekke ut disse koblingene:
Det siste vi skal snakke om, er et raskt tips for å håndtere store filer. Dette har noen ytelsesimplikasjoner.
Den enkleste måten å lese og sende ut en fil på er:
$ file = "test.txt"; ekko file_get_contents ($ file);
Men det fører til at hele innholdet i filen lastes inn i minnet. Det vil vare så lenge det blir lastet ned av nettoverskriften. Hvis du har flere personer som laster ned filer på samme tid, kan dette forbruke ditt webserverminne veldig raskt.
En bedre ide for å håndtere dette ville være å bruke en løkke til å bare lese små biter av filen om gangen. For sløyfeforholdet vil vi benytte feof-funksjonen:
$ file = "test.txt"; $ fp = fopen ($ file, 'r'); mens (! feof ($ fp)) echo fread ($ fp, 4092); fclose ($ fp);
Koden ovenfor vil bare laste 4kb data samtidig til minnet, og dette vil i stor grad redusere minnebruken for store filutganger. Feof-funksjonen returnerer sant når vi når slutten av filen, og dette bryter ut av løkken.
