hjem » Breaking

Opprett, åpne, les, skriv, slett og se etter fileksistens i PHP. Arbeide med Php-filsystemet ved å lese informasjon fra en fil tegn for tegn

Om bruk av funksjonene fopen, fclose, feof, fgets, fgetss og fscanf

La oss liste opp alle mulighetene

En av fordelene med å jobbe med moderne programmeringsspråk som PHP er antallet tilgjengelige funksjoner. PHP kan lett adoptere Perls motto, "Det er mer enn én måte å gjøre noe på," spesielt når det kommer til filbehandling. Men med mengden av tilgjengelige verktøy, blir spørsmålet hvilken som er best for å få jobben gjort. Selvfølgelig avhenger svaret på dette spørsmålet virkelig av hva målene dine er når du behandler filen, så å lære alle språkets evner er verdt tiden din.

Tradisjonelle fopen-metoder

Fopen-metodene er kanskje de mest kjente for tidligere tiders C- og C++-programmerere, siden de mer eller mindre er verktøyene som har vært tilgjengelige i mange år hvis du har jobbet med disse programmeringsspråkene. For noen av disse metodene følger du standardprosedyren, bruker fopen for å åpne filen, en funksjon for å lese dataene, og deretter flukk for å lukke filen, som vist i liste 1.

Liste 1. Åpne og lese en fil ved hjelp av fgets
$file_handle = fopen("minfil", "r"); while (!feof($file_handle)) ( $line = fgets($file_handle); echo $line; ) fclose($file_handle);

Selv om disse funksjonene er kjent for de fleste erfarne programmerere, la meg analysere hvordan de fungerer. I virkeligheten følger du disse trinnene:

  1. Åpne filen. $file_handle lagrer en lenke til selve filen.
  2. Sjekk om du har kommet til slutten av filen.
  3. Fortsett å lese filen til du kommer til slutten, og skriv ut hver linje du leser.
  4. Lukk filen.

Med det i tankene vil jeg se på hver filfunksjon som brukes her.

fopen funksjon

Fopen-funksjonen oppretter en tilkobling til en fil. Jeg sier "etablerer en tilkobling" fordi, i tillegg til å åpne en fil, kan fopen også åpne en URL:

$fh = fopen("http://127.0.0.1/", "r");

Denne programlinjen oppretter en lenke til siden ovenfor og lar deg begynne å lese den som en lokal fil.

Merk: Alternativet "r" som brukes i fopen indikerer at filen er åpen skrivebeskyttet. Siden skriving til en fil ikke er inkludert i omfanget av problemstillinger diskutert i denne artikkelen, vil jeg ikke liste opp alle mulige verdier for parameteren. Du må imidlertid endre "r" til "rb" hvis du leser fra binærfiler for kompatibilitet på tvers av plattformer. Nedenfor er et eksempel på denne typen.

feof funksjon

Feof-kommandoen bestemmer om lesingen har nådd slutten av filen og returnerer True eller False. Løkken vist i fortsetter til slutten av filen "minfil." Merk at feof også returnerer False hvis du leser en URL og tilkoblingen blir tidsavbrutt fordi det ikke er mer data å lese.

Funksjon flukk

La oss hoppe over midten av oppføring 1 og gå til slutten; fclose gjør det motsatte av fopen: den lukker forbindelsen til filen eller URL-en. Etter å ha utført denne funksjonen, vil du ikke lenger kunne lese fra filen eller kontakten.

fgets funksjon

Går du noen linjer tilbake i oppføring 1, kommer du til hjertet av filbehandlingsprosessen: faktisk lesing av filen. Fgets-funksjonen er ditt foretrukne våpen for det første eksemplet. Den henter en linje med data fra en fil og returnerer den som en streng. Derfra kan du vise dataene eller på annen måte behandle dem. Eksemplet i Oppføring 1 skriver ut hele filen.

Hvis du bestemmer deg for å begrense størrelsen på datadelen du jobber med, kan du legge til et fgets-argument for å begrense den maksimale lengden på datastrengen som fanges opp. Bruk for eksempel følgende kode for å begrense lengden på en linje til 80 tegn:

$string = fgets($file_handle, 81);

Tenk på "\0", end-of-line-indikatoren i C, og sett lengden til ett tegn lenger enn du faktisk trenger. Som du kan se, bruker eksemplet ovenfor 81, mens du trenger 80 tegn. Gjør det til en vane å legge til et ekstra tegn når du trenger å angi en linjelengdegrense for en gitt funksjon.

fread funksjon

Fgets-funksjonen er bare en av mange funksjoner som er tilgjengelige for å lese en fil. Dette er en av de mest brukte funksjonene, siden behandling av en fil linje for linje i de fleste tilfeller er mest fornuftig. Faktisk tilbyr flere andre funksjoner lignende funksjoner. Uansett, linje-for-linje-analyse er ikke alltid det du trenger.

Og her får vi tilgang til fread . Fread-funksjonen har et litt annet formål enn fgets: den er ment å lese fra binære filer (det vil si filer som i utgangspunktet ikke består av menneskelesbar tekst). Siden konseptet "linjer" ikke er relevant for binære filer (logiske datastrukturer er vanligvis ikke delt inn i linjer), må du spesifisere antall byte som skal leses.

$fh = fopen("minfil", "rb"); $data = fread($file_handle, 4096);

Eksemplet ovenfor leser 4096 byte (4 KB) med data. Merk at, uavhengig av verdien du angir, vil fread maksimalt lese 8192 byte (8 KB).

Forutsatt at filen ikke er større enn 8 KB, bør programutdraget nedenfor lese hele filen på én linje.

$fh = fopen("minfil", "rb"); $data = fread($fh, filstørrelse("minfil")); fclose($fh);

Hvis filstørrelsen er større, må du bruke en løkke for å lese resten av den.

fscanf funksjon

For å komme tilbake til strengbehandling, er fscanf også etterfølgeren til den tradisjonelle filbiblioteksfunksjonen i C. Hvis du ikke er kjent med den, leser fscanf datafelt til variabler fra en fil.

list ($felt1, $felt2, $felt3) = fscanf($fh, "%s %s %s");

Formatstrengene som brukes i denne funksjonen er beskrevet i mange kilder som PHP.net, så jeg vil ikke gjenta denne informasjonen her. Det er nok å si at strengformatering er veldig fleksibel. Det bør også nevnes at alle felt er plassert i variabelen som returneres av funksjonen. (I C vil disse bli sendt som argumenter.)

fgetss funksjon

Fgetss-funksjonen er forskjellig fra tradisjonelle filmanipuleringsfunksjoner og gir deg en bedre forståelse av PHPs muligheter. Det fungerer som fgets, men forkaster alle HTML- eller PHP-koder den oppdager, og etterlater bare den blotte teksten. La oss ta HTML-filen nedenfor.

Oppføring 2. Eksempel HTML-fil
Min tittel

Hvis du forstår hva "Cause there ain"t no one for to give you no pain" betyr, så hører du for mye på bandet America

La oss sende det gjennom fgetss-funksjonen.

Oppføring 3. Bruke fgetss
$file_handle = fopen("minfil", "r"); while (!feof($filhåndtak)) ( echo = fgetss($filhåndtak); ) fclose($filhåndtak);

Dette er hva du får som utdata:

Min tittel Hvis du forstår hva "Cause there ain"t no one for to give you no pain" betyr, så hører du for mye på bandet America

fpassthru-funksjon

Uansett hvordan du leser data fra en fil, kan du skrive ut de gjenværende dataene ved å bruke standard utgangskanal ved å bruke fpassthru-funksjonen.

fpassthru($fh);

Denne funksjonen skriver ut dataene slik at du ikke trenger å legge dem inn i en variabel.

Ikke-lineær filbehandling: flytte gjennom en fil

Selvfølgelig lar funksjonene beskrevet ovenfor deg bare lese fra en fil sekvensielt. Mer komplekse filer kan kreve flytting til forskjellige deler av filen på begynnelsen eller slutten av filen. For å gjøre dette trenger du fseek-funksjonen.

fseek($fh, 0);

Eksemplet ovenfor går tilbake til begynnelsen av filen. Hvis du ikke vil flytte helt til begynnelsen av filen - si, en kilobyte er nok - skriver du bare:

fseek($fh, 1024);

Fra og med PHP V4.0 er flere andre alternativer også tilgjengelige. For eksempel, hvis du trenger å gå 100 byte fremover fra din nåværende posisjon, kan du bruke følgende kode:

fseek($fh, 100, SEEK_CUR);

På samme måte gjøres flytting tilbake 100 byte ved å:

fseek($fh, -100, SEEK_CUR);

Hvis du vil gå tilbake til 100 byte-posisjonen før slutten av filen, bruk SEEK_END i stedet.

fseek($fh, -100, SEEK_END);

Når den nye posisjonen er nådd, kan du bruke fgets, fscanf eller en annen funksjon for å lese dataene.

Merk: du kan ikke bruke fseek på filbeskrivelser som refererer til en URL.

Ta en hel fil

Nå går vi videre til å se på noen av PHPs unike filbehandlingsmuligheter: behandling av store datablokker på én eller to linjer. Hvordan kan du for eksempel hente en fil og vise hele innholdet på nettsiden din? Vel, du har sett et eksempel på bruk av en loop med fgets. Men hvordan kan du gjøre det enklere? Prosessen er nesten latterlig enkel ved å bruke fgetcontents, som setter hele filen på en linje.

$my_file = file_get_contents("mittfilnavn"); echo $min_fil;

Selv om dette ikke er det beste alternativet, kan du skrive denne kommandoen enda kortere:

echo file_get_contents("mittfilnavn");

Denne artikkelen fokuserer først og fremst på behandling av lokale filer, men det er verdt å merke seg at du også kan fange opp, vise og analysere andre websider ved å bruke funksjonene som er beskrevet.

echo file_get_contents("http://127.0.0.1/");

Denne kommandoen er faktisk den samme som:

$fh = fopen("http://127.0.0.1/", "r"); fpassthru($fh);

Du ser kanskje på disse eksemplene og tenker: "Det er mye arbeid." PHP-utviklere er enige med deg. Så du kan forkorte kommandoen ovenfor til:

readfile("http://127.0.0.1/");

Lesefilfunksjonen sender ut hele innholdet i en fil eller webside til standard utdatabuffer. Som standard viser denne kommandoen en feilmelding når den mislykkes. For å unngå denne oppførselen (hvis du ønsker det), prøv kommandoen:

@readfile("http://127.0.0.1/");

Selvfølgelig, hvis du trenger å behandle innholdet i filer, er den enkle linjen returnert av file_get_contents sannsynligvis for mye. Du vil kanskje først dele den opp i deler ved å bruke split()-funksjonen.

$array = split("\n", file_get_contents("minfil"));

Men hvorfor trenger du all denne kompleksiteten hvis det er en perfekt egnet funksjon som vil gjøre jobben for deg? PHP file()-funksjonen utfører denne oppgaven i ett trinn: den returnerer en string-array hvis elementer er linjene i filen.

$array = fil("minfil");

Det skal bemerkes at det er en liten forskjell mellom de to eksemplene ovenfor. Split-kommandoen fjerner nye linjer, mens filkommandoen avslutter array-linjene med nye linjer (det samme gjør fgets).

PHPs evner går imidlertid langt utover de som er beskrevet ovenfor. Du kan analysere hele .ini-filer i PHP-stil med bare én parse_ini_file-kommando. Kommandoen parse_ini_file gjelder for filer som ligner på de som er vist i oppføring 4.

Oppføring 4. Eksempel .ini-fil
; Kommentarnavn = "Kong Arthur"-oppdrag = Å søke den hellige gral favorittfarge = Blå Samuel Clemens = Mark Twain Caryn Johnson = Whoopi Goldberg

Følgende kommandoer representerer en fil som en matrise og skriver deretter ut matrisen:

$file_array = parse_ini_file("holy_grail.ini"); print_r $filearray;

Resultatet vil være følgende utgang:

Oppføring 5. Utgang
Array ( => Kong Arthur => Å søke den hellige gral => Blå => Mark Twain => Whoopi Goldberg)

Selvfølgelig kan du legge merke til at denne kommandoen har slått sammen seksjonene. Dette er standardhandlingen, men du kan enkelt tilpasse den ved å bruke det andre argumentet til parse_ini_file: process_sections, som er en boolsk variabel. Sett process_sections til True.

$file_array = parse_ini_file("holy_grail.ini", true); print_r $filearray;

Og utdataene dine vil se slik ut:

Oppføring 6. Utgang
Array ( => Array ( => Kong Arthur => For å søke den hellige gral => Blå) => Array ( => Mark Twain => Whoopi Goldberg))

PHP legger dataene inn i en lett parserbar flerdimensjonal matrise.

Men dette er bare toppen av isfjellet når det kommer til filbehandling i PHP. Mer komplekse funksjoner som tidy_parse_file og xml_parse kan hjelpe deg med å analysere henholdsvis HTML- og XML-dokumenter. Se avsnittet for mer detaljert informasjon om hvordan disse funksjonene fungerer. Begge disse er verdt å vurdere hvis du skal jobbe med disse filtypene, men i stedet for å gå gjennom alle mulige filtyper, kan det være lurt å se nærmere på innholdet i denne artikkelen, som har noen gode generelle regler for arbeider med funksjonene jeg har beskrevet så langt.

God programmeringsstil

Anta aldri at alt i programmet vil fungere etter hensikten. For eksempel: hva om filen du leter etter har blitt flyttet? Hva om en tillatelsesendring fører til at du ikke kan lese innholdet i en fil? Du kan sjekke eksistensen av en fil og rettighetene til å lese den på forhånd ved å bruke metodene file_exists og is_readable.

Oppføring 7. Bruke file_exists og is_readable
$filnavn = "minfil"; if (fil_eksisterer($filnavn) && er_lesbar ($filnavn)) ( $fh = fopen($filnavn, "r"); # Behandler fclose($fh); )

Men i praksis vil dette programmet sannsynligvis være overkill for oppgaven din. Håndtering av verdiene som returneres av fopen er enklere og mer nøyaktig.

if ($fh = fopen($filnavn, "r")) ( # Behandler fclose($fh); )

Siden fopen returnerer False hvis den mislykkes, vil dette sikre at filen kun blir behandlet hvis filen kan åpnes. Selvfølgelig, hvis filen ikke eksisterer eller er uleselig, forventer du at returverdien er negativ. Derfor er en slik sjekk en felle som alle potensielle problemer faller i. Alternativt kan du avslutte programmet eller vise en feilmelding hvis filen ikke kan åpnes.

Som fopen returnerer file_get_contents, file og readfile-funksjonene False hvis filen ikke kan åpnes eller behandles. Funksjonene fgets, fgetss, fread, fscanf og fclose returnerer også False hvis det oppstår en feil. Selvfølgelig, med unntak av fclose , har du sannsynligvis allerede behandlet resultatene de returnerer. Når det gjelder fclose , er det ikke mye som kan gjøres hvis filhåndtaket ikke lukkes ordentlig, så å sjekke returverdien til fclose er generelt overkill.

Valget er ditt

PHP har ingen mangel på effektive måter å lese og analysere filer på. Klassiske funksjoner som fread kan tjene deg pålitelig mesteparten av tiden, eller du kan være mer tiltrukket av enkelheten til readfile hvis det er det du trenger for å få jobben gjort. Valget avhenger egentlig av hva du prøver å oppnå.

Hvis du behandler store datamengder, vil du sannsynligvis finne fscanf mer nyttig og effektivt enn for eksempel å bruke fil i kombinasjon med de påfølgende split- og sprintf-kommandoene. Hvis du bare viser en stor mengde tekst med mindre endringer, kan det være mer fornuftig å bruke filen , file_get_contents eller readfile-funksjonene. Denne løsningen vil sannsynligvis være riktig når du bruker PHP for caching eller til og med opprette en midlertidig proxy-server.

PHP gir mange verktøy for å jobbe med filer. Bli bedre kjent med hver enkelt og finn ut hvilke verktøy som er best for prosjektet du jobber med. Du tilbys et bredt utvalg av programvareverktøy, bruk dem mest effektivt og ha det gøy med å behandle filene dine ved hjelp av PHP.

Hver programmerer bør kunne jobbe med filer på riktig måte. Denne artikkelen er rettet mot nybegynnere PHP-programmerere, men "samlingen av oppskrifter" vil også være nyttig for avanserte brukere.

Arbeid med filer er delt inn i 3 trinn:

  1. Åpne en fil.
  2. Datamanipulasjon.
  3. Lukker filen.

Jeg. Åpne en fil

For å åpne en fil i PHP-miljøet, bruk funksjonen fopen(). De nødvendige parameterne for denne funksjonen er filnavnet og filmodusen.

$fp = fopen("counter.txt", "r");

I følge PHP-dokumentasjonen skilles følgende typer filmoduser ut:

  1. r – åpne filen for skrivebeskyttet.
  2. r+ - åpner en fil for lesing og skriving samtidig.
  3. w – oppretter en ny tom fil. Hvis en slik fil allerede eksisterer på tidspunktet for samtalen, blir den ødelagt.
  4. w+ - ligner på r+, bare hvis en slik fil eksisterer på tidspunktet for anropet, blir innholdet slettet.
  5. a – åpner en eksisterende fil i skrivemodus, med pekeren flyttet til siste byte av filen (til slutten av filen).
  6. a+ - åpner en fil i lese-skrivemodus, med pekeren flyttet til siste byte av filen (til slutten av filen). Innholdet i filen slettes ikke.

Merk: Det kan være enda en valgfri parameter på slutten av en av linjene: b eller t . Hvis b er spesifisert, åpnes filen i binær lese-/skrivemodus. Hvis t, er satt for filen, dvs. det oppfattes som tekstlig.

For å demonstrere, vurder følgende scenario:

//Åpner en fil i forskjellige moduser
$fp = fopen("counter.txt", "r"); // Binær modus
$fp = fopen("counter.txt", "rt"); // Tekstmodus
$fp = fopen("http://www.yandex.ru", "r");// Åpner en HTTP-tilkobling for lesing
$fp = fopen("ftp://bruker: [e-postbeskyttet]", "w"); //Åpne en FTP-tilkobling som indikerer pålogging og passord
?>

II. Fildatamanipulering

Du kan skrive data til en fil ved hjelp av PHP ved å bruke funksjonen fwrite(). Denne funksjonen tar 2 nødvendige parametere og 1 valgfri. De nødvendige parameterne er filbeskrivelsen og filmodusen:

$fp = fopen("counter.txt", "a"); // Åpne filen i skrivemodus
$mytext = "Vi må skrive denne linjen\r\n"; // Kildestreng
$test = fwrite($fp, $mintekst); // Skriv til fil
if ($test) echo "Dataene ble lagt inn i filen.";
else echo "Feil ved skriving til fil.";
fclose($fp); //Lukk filen
?>

For å lese en fil linje for linje, bruk funksjonen fgets(). Funksjonen tar 2 nødvendige parametere:


hvis ($fp)
{
while (!feof($fp))
{
$mintekst = fgets($fp, 999);
echo $mytext."
";
}
}

fclose($fp);
?>

Merk: I dette eksemplet spesifiserer verdien 999 antall tegn som skal leses til pekeren når slutten av filen (EOF).

For å lese filen som en helhet, må du bruke funksjonen lesefil(), som tar 1 nødvendig parameter. Funksjonen åpner en fil, viser innholdet i et nettleservindu, og lukker deretter filen:

echoreadfile("counter.txt");
?>

Du kan også bruke funksjonen fpassthru() som tar 1 nødvendig parameter. Før du bruker denne funksjonen, må du åpne filen i lesemodus. Når filen er ferdig lest, lukker funksjonen automatisk filen (og filbeskrivelsen blir ugyldig).

$fp = fopen("counter.txt", "r"); // Åpne filen i lesemodus
if ($fp) echo fpassthru($fp);
elseecho "Feil ved åpning av fil";
?>

Svært ofte er det situasjoner når det er nødvendig å lese innholdet på et nettsted inn i en matrise. Denne funksjonen innebærer bruk av funksjonen fil(). Når denne funksjonen kalles opp, vil hver linje i filen bli lagret i et separat element i den angitte matrisen.

Merk: Funksjonen skal ikke brukes fil() til binære filer (binært-safe), fordi Det er ikke trygt å lese binære filer, og hvis den støter på et filslutttegn (EOF) et sted, garanterer det ikke at du vil lese hele den binære filen.

$fil_array = fil("counter.txt"); // Les filen inn i $file_arrayen
// Arbeide med matrisedata
?>

Merk: Arbeid med arrays er beskrevet i detalj, forfattere: Mukhametshin D.F., Simdyanov I.V.

På slutten av artikkelen finner du en god "oppskriftsbok" om matriser, som gir løsninger på mange problemer som en nettprogrammerer møter hver dag.

La oss forestille oss en situasjon der en fil må leses tegn for tegn. For å gjøre dette kan vi bruke funksjonen fgetc(). Funksjonen tar en enkelt parameter. Funksjonen er nyttig hvis vi trenger å finne et hvilket som helst tegn eller antall identiske tegn.

$fp = fopen("counter.txt", "r"); // Åpne filen i lesemodus
hvis ($fp)
{
while(!feof($fp))
{
$char = fgetc($fp);
if ($char == "c") $i = $i + 1;// Finn tegnet "c"
}
echo "Antall 'c'-bokstaver i filen: ". $i;
}
else echo "Feil ved åpning av fil";
?>

III. Lukke en fil

Filen lukkes ved hjelp av funksjonen fclose(), som tar 1 nødvendig parameter.

$fp = fopen("counter.txt", "r");
hvis ($fp)
{
echo "Filen er åpen";
fclose($fp); // Lukking av filen
}
?>

Samling av oppskrifter

1) Vi må sjekke om denne eller den filen eksisterer. For å gjøre dette bruker vi funksjonen Filen eksisterer().

myfile("counter.txt"); // Bruk myfile-funksjonen ved å sende filnavnet som et argument

function myfile($name) //Opprett en funksjon for å sjekke eksistensen av en fil
{
if (file_exists($name)) echo "Filen eksisterer";

}
?>

Merk: Funksjon Filen eksisterer sjekker ikke filene på den eksterne webserveren. For at funksjonen skal fungere riktig, må filen med skriptet ligge på samme server som filen som kontrolleres.

2) Bestem filstørrelsen ved hjelp av funksjonen filstørrelse()

myfile("counter.txt");

function myfile($name) //Opprett en funksjon for å sjekke eksistensen av en fil og bestemme filstørrelsen
{
if (file_exists($name)) echo "Filstørrelse: ".filesize($name)." bytes";
else echo "Filen eksisterer ikke";
}
?>

3) Opprett en midlertidig fil ved hjelp av funksjonen tmp-fil()

$minfil = tmpfil();
fwrite($myfile, "Denne linjen er skrevet til en midlertidig fil."); // Skriv til en midlertidig fil
fseek($minfil, 0); // Sett filpekeren
echo fread($minfil, 1024); // skriv ut innholdet i filen
?>

4) Du må bestemme antall linjer i filen. For å gjøre dette bruker vi funksjonen telle()

$fp = file("counter.txt");
echo "Antall linjer i filen: ".count($fp);
?>

5) Vi må bruke en fillåsemekanisme

$fp = fopen("counter.txt", "a");
flock($fp, LOCK_EX); // Lås filen for skriving
fwrite($fp, "Linje å skrive");
flock($fp, LOCK_UN); // Lås opp
fclose($fp);
?>

6) Vi må fjerne en bestemt linje fra filen

$num_stroka = 5; //Slett linje 5 fra filen
$fil = fil("counter.txt"); // Les hele filen inn i en matrise

for($i = 0; $i< sizeof($file); $i++)
if($i == $num_stroka) unset($fil[$i]);

$fp = fopen("counter.txt", "w");
fputs($fp, implode("", $fil));
fclose($fp);
?>

7) Bestemme filtypen. Bruker funksjonen

Og nå blir det en ganske stor, men ikke komplisert leksjon om å jobbe med filer i PHP. Først av alt, hva er filene til? Tross alt kan du lagre alt i en MySQL eller PostgreSQL eller en hvilken som helst annen database. Men noen ganger er det oppgaver når du bruker en database, med all behandling og bekymring for tilkoblingssikkerhet, er ikke tilrådelig. For eksempel må vi lage en vanlig teller, men før dette brukte vi ikke en database i prosjektet. Så, for en liten teller, bør vi lage en database og lagre bare et par linjer i den? Det er mye enklere å bruke filer her. I tillegg, noen ganger ikke hosting støtter databaser i det hele tatt, da filer er vanligvis det eneste alternativet.

Vel, la oss si at jeg overbeviste deg om at filene er nødvendige :) La oss nå finne ut hvordan vi jobber med dem. Hvordan lage, åpne, skrive, overskrive, lese og så videre. Første ting først.

Opprett en fil

PHP bruker fopen-funksjonen til å åpne filer. Den kan imidlertid også lage filer. Hvis du sender fopen et filnavn som ikke eksisterer, vil det opprette det.

Selve fopen-funksjonen tar to parametere, som begge er nødvendige. Først må vi spesifisere navnet på filen vi vil åpne. For det andre, send en parameter som forteller funksjonen hva vi planlegger å gjøre med denne filen (for eksempel lese fra filen, skrive, etc.).

Hvis vi trenger å lage en fil, spesifiserer vi navnet og sender parameteren som vi vil skrive data til den. Merk: Vi må sørge for å fortelle PHP hva vi skriver til filen, ellers vil den ikke opprette en ny fil.

Eksempel:

$ourFileName = "testFile.txt";

$ourFileHandle = fopen($ourFileName, "w") eller die("kan"ikke åpne filen");

fclose($ourFileHandle);

Den første linjen $ourFileName = testFile.txt lager en strengvariabel der vi lagrer filnavnet.

Den andre linjen $ourFileHandle = fopen($ourFileName, ‘w’) eller die(“can't open file”) oppretter eller åpner henholdsvis en eksisterende fil for skriving. Eller den returnerer en melding om at den ikke kan åpne filen.

Den tredje linjen fclose($ourFileHandle) lukker filen. Det er faktisk enkelt.

Filåpningsalternativer i php

Den første parameteren 'r' (les) - åpner filen for skrivebeskyttet; du kan ikke skrive til den.

Den andre parameteren 'w' (skriv) – åpner for skriving. I dette tilfellet vil opptaket alltid gå fra begynnelsen av filen. Hvis det allerede er noe informasjon der, vil den bli overskrevet.

Den tredje parameteren 'a' (legg til) - åpner filen for skriving, men vil legge til på slutten av filen, i motsetning til w.

Avanserte alternativer:

Parameter 'r+' - åpner for både lesing og skriving. Pekeren vil være i begynnelsen av filen.

Parameter 'w+' - åpner for både lesing og skriving, MEN sletter all informasjon som var i filen!!!

parameter 'a+' - åpner for lesing og skriving, men pekeren vil være på slutten av filen.

Naturligvis kan bare én av disse parameterne overføres til en funksjon, og ikke flere. De må erstattes med "X":

fopen($ourFileName, "X")

Skriv til fil

Vel, nå har vi åpnet filen, valgt parameteren vi trenger, hva neste? Du må skrive noe i den. Hvordan gjøre det? Ved å bruke fwrite-funksjonen, som tar som parametere en peker til en fil og en tekstlinje som vi ønsker å skrive. Eksempel:

$myFile = "testFile.txt";

$fh = fopen($myFile, "w") eller die("kan ikke åpne filen");

$stringData = "Første linje";

fwrite($fh, $stringData);

$stringData = "Andre linje";

fwrite($fh, $stringData);

Vi opprettet en fil testFile.txt, pekeren til den er lagret i $fn-variabelen. Vi skrev linjen "Første linje" inn i den (på slutten brukte vi linjesluttsymbolet n), og deretter "Andre linje". Så lukket de filen.

MERK FØLGENDE! Glem aldri å lukke filene dine! Ellers, hvis skriptkjøringen avsluttes unormalt, vil ikke dataene i filene bli lagret! Bruk alltid fclose etter jobb!!!

Leser fra en fil

Vi har skrevet det ned, la oss nå lese det! Det er ikke så vanskelig heller. Vi bruker fread-funksjonen. Som input gir vi den en peker til filen og antall byte vi ønsker å lese. For eksempel, ett tegn er lik en byte (avhengig av kodingen), vi ønsker å lese 5 tegn: $theData = fread($fh, 5).

Men hvis vi trenger å få all informasjonen som er i filen, vil vi trenge filstørrelsesfunksjonen, som returnerer antall byte i filen, derfor, hvis resultatet av filstørrelsesfunksjonen sendes til fread, vil vi få all informasjon fra filen:

$myFile = "testFile.txt";

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

$theData = fread($fh, filstørrelse($myFile));

Jeg håper jeg forklarte det tydelig.

$myFile = "testFile.txt";

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

$theData = fgets($fh);

Som et resultat får vi den første linjen fra testFile.txt-filen. Følgelig, for å gå gjennom alle linjene, må du bruke en forhver løkke:

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

foreach($lines som $single_line)

echo $single_line . "
n";

Nå har du lært hvordan du åpner filer for lesing, skriving eller begge deler. Skriv data til dem eller legg dem på toppen ved hjelp av Append, og les også informasjon fra dem.

Under arbeider med filer i PHP underforstått lesing fra fil Og skrive til filen ulike opplysninger. Det er åpenbart at du må jobbe mye med filer, så evt PHP programmerer Må kunne lese fra fil Og skrive til filen.

Etterfølge arbeider med filer i PHP som dette:

  1. Åpen fil.
  2. Utfør de nødvendige handlingene.
  3. Lukk filen.

Som du kan se, ligner sekvensen for arbeid med filer å jobbe med filer gjennom en vanlig utforsker. Bare her gjøres alt arbeidet automatisk av oss selv PHP-skript.

La oss starte med det første punktet - åpne filen. Filen åpnes med fopen() funksjoner. Den første parameteren er filbanen og den andre parameteren er modifikator. La oss umiddelbart se på de mulige modifikatorene:

  1. en- åpner filen kun for skriving, med pekeren plassert på slutten av filen.
  2. a+ en, men filen åpnes også for lesing.
  3. r- åpner filen for skrivebeskyttet, og pekeren settes til begynnelsen av filen.
  4. r+- samme som modifikator r, men filen åpnes også for skriving.
  5. w- åpner filen kun for skriving, setter pekeren til begynnelsen av filen og sletter hele innholdet i filen.
  6. w+- samme som modifikator w, bare filen åpnes også for lesing.

Det er også to moduser for arbeid med filer: binær(betegnet b) Og tekst(betegnet t). Hvis du jobber med en vanlig tekstfil, velg tekstmodus, og hvis for eksempel med et bilde, velg binær modus.

Dette er alle de grunnleggende modifikatorene, som vil være nok for deg. La oss nå lære hvordan du lukker en fil. Lukker filen med fclose() funksjoner.

La oss nå gå videre til å lese filen med fread() funksjoner. Og la meg til slutt gi deg et eksempel:

$contents = "";
while (!feof($handle))
$innhold .= fread($handle, 4096);
fclose($handle);
?>

I dette eksemplet åpner vi først filen for lesing i tekstmodus (modifier rt). fopen() funksjon returnerer den såkalte beskrivelse, som du kan kommunisere med filen med, og skrive den til en variabel håndtak. Da er vi i en løkke samtidig som() til slutten av filen er nådd, leser vi innholdet hver gang 4096 tegn som vi skriver til variabelen innhold. Etter at leseprosessen er fullført, lukk filen, igjen ved å bruke filbeskrivelsen.

La oss nå gå videre til opptak ved hjelp av fwrite() funksjoner:

$handle = fopen("filer/a.txt", "at");
$string = "Dette er tekst";
fwrite($håndtak, $streng);
fclose($handle);
?>

Etter å ha kjørt dette skriptet, i filen a.txt linjen " vil bli lagt til Dette er tekst".

Spesielt oppmerksomme lesere tok hensyn til tipsene jeg skrev om rett ovenfor. Peker- dette er den nåværende posisjonen til den imaginære "markøren" i filen. Det er her arbeidet med filen begynner. Du kan endre posisjonen til pekeren ved å bruke fseek() funksjoner:

$handle = fopen("filer/a.txt", "rt");
ekko $innhold."
";
fseek($håndtak, 0, SEEK_SET);
$innhold = fread($håndtak, 3);
ekko $innhold."
";
?>

Så vi leste først 3 tegn (som et resultat blir gjeldende pekerposisjon forskjøvet med 3 stillinger). Vi setter deretter pekeren til begynnelsen av filen. Og vi leser igjen 3 symbol. Som du kanskje har gjettet, telte vi det samme to ganger. Det er første gang 3 symbol, gikk deretter tilbake og telte igjen 3 symbol. Også hvis du fseek() funksjoner erstatte SEEK_SET på SEEK_CUR, vil ikke den andre parameteren angi pekerposisjonen, men vil forskyve den i forhold til gjeldende plassering. Jeg råder deg til og med å øve med pekere, for det er ikke så lett å forstå. Jeg anbefaler også å prøve å skrive noe til filen ved pekerposisjonen, for eksempel helt i begynnelsen av filen. Og sørg for å forklare resultatene dine.

Og til slutt vil jeg gi et par flere funksjoner som lar deg jobbe med filer på det enkleste nivået: file_put_contens() Og file_get_contents(). Funksjon file_put_contents() skriver til en fil, og funksjonen file_get_contents() leser innhold fra en fil. Disse funksjonene er veldig enkle å bruke, men det er færre alternativer (selv om de som regel ikke er nødvendige):

file_put_contents("filer/a.txt", "Dette er tekst 2");
echo file_get_contents("filer/a.txt");
?>

I dette manuset skrev vi først linjen " Dette er tekst 2" til en fil, og så leser vi det resulterende innholdet og sender det ut. Som du kan se, er det vanskelig å komme opp med en enklere måte lesing fra fil Og skrive til filen.

Det er alle hovedpoengene arbeider med filer i PHP.