Arbeide med filer i php: åpne, skrive, lese. Hvordan lese filer korrekt ved å bruke PHP Php-lesing fra en fil

PHP

file_exists("test.txt")//Eksisterer filen? filesize("test.txt");//Finn ut filstørrelsen //Tidsstempelet returneres: fileatime("test.txt");//Dato for siste tilgang til filen //date("d M Y" , $atime); filemtime("test.txt");//Dato for filendring //date("d M Y", $mtime); filectime("test.txt");//Dato for filoppretting (Windows) //date("d M Y", $ctime);

Filer: driftsmoduser

PHP

ressurs fopen (streng filnavn, strengmodus) // ressurs - returnerer en peker til filen i tilfelle suksess, eller FALSE i tilfelle feil

Driftsmodus	Beskrivelse
r	åpen fil skrivebeskyttet;
r+	åpne filen for lesing og skriving;
w	åpne filen kun for skriving. Hvis den eksisterer, blir det gjeldende innholdet i filen ødelagt. Gjeldende posisjon er satt til begynnelsen;
w+	åpne filen for lesing og skriving. Hvis den eksisterer, blir det gjeldende innholdet i filen ødelagt. Gjeldende posisjon er satt til begynnelsen;
EN	åpne filen for skriving. Gjeldende posisjon er satt til slutten av filen;
a+	åpne filen for lesing og skriving. Gjeldende posisjon er satt til slutten av filen;
b	behandle den binære filen. Dette flagget kreves når du arbeider med binære filer på Windows.

Åpne og lukke filer i PHP

PHP

$fi = fopen("test.html", "w+") eller die("Feil"); //Eksempler $fi = fopen("http://www.you/test.html","r"); $fi = fopen("http://ftp.you/test.html", "r"); //Lukk fclose($fi)

Leser filer i PHP

PHP

//Les filen fread(int fi, int lengde) $str = fread($fi, 5); // Les de første 5 tegnene echo $str; // siden markøren har flyttet $str = fread($fi, 12); // Les de neste 12 tegnene echo $str; fgets(int fi[, int lengde]) // Les en linje fra en fil fgetss(int fi, int lengde [, streng tillatt]) // Les en linje fra en fil og forkast HTML-koder // streng tillatt - tagger som må stå igjen fgetc(int fi) //Leser et tegn fra en fil

Til å begynne med vil skrivingen skje i begynnelsen av filen, ved å overskrive eksisterende data, hvis noen. Derfor, hvis du trenger å skrive noe til slutten av filen, må du angi riktig lesemodus, for eksempel a+ .

Markørmanipulasjon i PHP-filer

PHP

int fseek(int fi, int offset [, int wherece]) //Setter markøren // int fi - peker til filen //offset - antall tegn som skal flyttes. //hvor: //SEEK_SET - bevegelse starter fra begynnelsen av filen; //SEEK_CUR - bevegelse starter fra gjeldende posisjon; //SEEK_END - bevegelse starter fra slutten av filen. fseek($fi, -10, SEEK_END); //Les de siste 10 tegnene $s = fread($fi, 10); $pos = ftell($fi); //Finn ut gjeldende posisjon spole tilbake($f)//reset markøren bool feof($f) //slutt av filen

Direkte arbeid med filer (data) i PHP

PHP

array file(string filename) // Få innholdet i filen i form av en array // Et annet alternativ for direkte arbeid med data file_get_contents(string filename) // Lesing (får hele filen på én linje) // Skrive til filen (opprinnelig overskrevet) file_put_contents (streng filnavn, blandede data[,int flagg]); //FILE_APPEND // Skriv til slutten av filen: file_put_contents("test.txt", "data", FILE_APPEND); //Hvis du skriver en array, $array = array("I", "live"); file_put_contents("test.txt",$array); //da får vi "Ilive"

Administrere filer i php

PHP

copy(strengkilde, strengdestinasjon); // Kopiering av filen rename(str oldname, str newname); // Gi nytt navn til filen unlink (streng filnavn); // Sletting av en fil

Laster opp filer til PHP-server

//PHP.ini-innstillinger file_uploads (på|av) // tillat eller forby filopplasting upload_tmp_dir // midlertidig mappe for opplastede filer. som standard midlertidig mappe upload_max_filesize (standard = 2 Mb) // maks. last opp filstørrelse post_max_size // total størrelse på det innsendte skjemaet (må være større enn upload_max_filesize) // Enkel opplasting

HTML

Arbeide med filer på serveren

PHP

//Godta data $tmp = $_FILES["brukerfil"]["tmp_name"]; $navn = $_FILES["brukerfil"]["navn"]; //Flytt filen move_uploaded_file($tmp, navn); move_uploaded_file($tmp, "upload/".navn); // omdirigere filen til opplastingsmappen // i forhold til gjeldende fil // Hva er i $_FILES-matrisen $_FILES["brukerfil"]["navn"] // filnavn, for eksempel test.html $_FILES[ "userfile"][" tmp_name"] // midlertidig filnavn (bane) $_FILES["brukerfil"]["size"] // filstørrelse $_FILES["brukerfil"]["type"] // filtype $ _FILES["brukerfil"] ["feil"] // 0 - ingen feil, nummer - ja

PHP dukket opp mye senere enn programmeringsspråk styrket sine posisjoner og formulerte generelle ideer om syntaks, logikk, variabler og andre programobjekter. Filer og funksjoner for å jobbe med dem gjorde ikke fremskritt, og selv problemet med filkoding, som oppsto av naturlige årsaker, førte ikke til radikalt nye løsninger.

Generelle bemerkninger

Hovedarbeidet med filer, uansett hva de er, består av åpning, lesing/skriving og lukking. Du kan bruke funksjonene for å blokkere/oppheve blokkering av tilgang til en fil mens den behandles, du kan stille inn lese/skrive-posisjonen i filen – alt er det samme som før, i en fjern fortid.

Et viktig poeng i PHP er overfloden av funksjoner for å jobbe med filer og alternativer for å bruke dem. I praksis er det nok å bruke enkle, men fungerende alternativer. En fil er for det første programminne. Du kan lagre informasjon i den. Formålet med ethvert program, formålet med ethvert nettsted er å presentere, behandle og sikre sikkerheten til informasjon.

Viktig omstendighet

Tidligere var kravet til kompatibilitet, i hvert fall fra bunn til topp, urokkelig. Det vil si at et program som en gang er skrevet i én versjon av et programmeringsspråk, ideelt sett kompileres/tolkes i neste versjon. I moderne programmering er dette ikke tilfelle. Kravet om kompatibilitet av syntaktiske strukturer i et språk har blitt en ting fra historien, og kampen mellom stiler og programmeringsverktøy og versjoner av visse verktøy har blitt normen i livet deres.

Å jobbe med filer, så vel som med databaser, er like viktig som nettstedets grensesnitt. Den første bør bygges på en slik måte at når du endrer plattform, hosting eller språkversjon, er det ikke nødvendig å endre nettstedskoden. Grensesnittet for arbeid med filer må inkluderes i et eget skript og sikre full kompatibilitet, akkurat som nettsteddesignet må tilpasses til enhver enhet, nettleser og gi resten av nettstedets funksjonalitet de samme egenskapene.

Les og endre deg selv

Kan et program endre seg selv, det vil si, kan et script forbedres? Den dag i dag interesserer dette spørsmålet mange. Men oppgaven høres mye mer praktisk ut: PHP leser en PHP-fil. En utvikler kan ikke alltid løse et bestemt problem ved å skrive spesifikk kode. Noen ganger er det nødvendig å endre det når en besøkende kommer til nettstedet og formulerer et spørsmål som ikke var forutsett på utviklingsstadiet.

Som i alle andre tilfeller må du først og fremst åpne filen. Det spiller ingen rolle om denne filen eksisterer eller ikke. Hvis det er kjent at filen eksisterer (fil_exists()-funksjonen gir et positivt svar), brukes fopen()-funksjonen med tilgang 'r', 'r+', 'a', 'a+'. Hvis filen ikke eksisterer ennå, med tilgang 'a', 'a+', 'w', 'w+'. Resultatet av å åpne en fil vil være dens beskrivelse. Filen lukkes med funksjonen fclose().

Det er praktisk å bruke PHP til å lese en fil inn i en array når det ikke er behov for å behandle den på lesingstidspunktet.

if (fil_eksisterer($fName)) (

$aLines = fil($fName)

I dette alternativet går hver linje i filen inn i array-elementet sekvensielt. Det skal bemerkes at file()- eller file_get_contents()-funksjonene ikke trenger å åpne filen og lukke den.

Når inndatafilen er for stor og du bare trenger å finne litt informasjon, eller av andre grunner, kan du bruke PHP til å lese filen linje for linje. PHP gir muligheten til å gjøre dette med funksjonene fgets() og fgetc().

$fvs = fopen($fName, "r")

while ((false !== ($cLine = fgets($fvs, 2000)))) (

$cLines .= "
". $i. "). " . $cLine

Begge alternativene fungerer feilfritt. Men når du utfører PHP-lesing av en PHP-fil for senere modifikasjon, bør forholdsregler tas. Det er ikke alltid mulig å forutse hvordan en besøkende vil bruke det på utviklingsstadiet. Det er bedre hvis skriptene endres innenfor nettstedets funksjoner, og kontroll over denne endringen er ikke tilgjengelig for besøkende, inkludert ressursadministratoren.

Lagrer resultater

Den mottatte og oppdaterte informasjonen skrives til filen av funksjonen fputs() linje for linje eller av funksjonen file_put_contents() som helhet.

$fName = $_SERVER["DOCUMENT_ROOT"] . "/tmp/scData.php"

$fvs = fopen($fName, "a")

flock($fvs, LOCK_EX)

$cLine = "1 linje". chr(10)

fputs($fvs, $cLine)

$cLine = "2 linjer" . chr(10)

fputs($fvs, $cLine)

flock($fvs, LOCK_UN)

I linje-for-linje-opptaksalternativet kan du manipulere data under opptaksprosessen; i det andre tilfellet plasseres den skrevne strengen eller matrisen i hele filen.

$fil = " scData.php "

$cContents = file_get_contents($file)

// legge til en oppføring

$cContents .= "ny oppføring\n"

// skriv filen tilbake

file_put_contents($fil, $cContents)

Å lese og skrive PHP-filer er enkelt og naturlig. Det er imidlertid viktig å huske på: hver fil har et navn, utvidelse og bane (mappe). For at et PHP-skript skal kunne lese og skrive filer, må dette skriptet ha de riktige rettighetene. De blir automatisk eksponert på hostingen, men i noen tilfeller må de utvides.

I noen tilfeller kan det være ønskelig å verifisere resultatene ved å utføre en testavlesning. Å skrive PHP-filer krever dette under utvikling, men i noen tilfeller, av hensyn til nettstedets sikkerhet eller pålitelighet, er det viktig å sjekke dataregistrering.

Et karakteristisk trekk ved PHP, MySQl, JavaScript og spesielt nettlesere: lar noen feil skje. "Ikke anerkjent, ikke gjort ..." er ikke en veldig god praksis på forkant av informasjonsteknologi, men det lærer utviklere å ikke gjøre feil og skrive ren kode av høy kvalitet, noe som heller ikke er dårlig.

PHP og arbeid med ekte dokumenter

PHP å lese en PHP-fil er absolutt av praktisk interesse, men dette er programmeringsområdet. Brukeren og nettstedets besøkende er interessert i informasjon av anvendt karakter, som han er vant til å se i form av tabeller og dokumenter, spesielt i filformatene *.xlsx og *.docx. Dette er filer i MS Excel og MS Word-format.

Lister over varer, priser, egenskaper er vanligvis dannet i form av tabeller, så PHP-lesing av Excel-filen er viktig.

PHPExcel- og PHPWord-bibliotekene er utviklet for å fungere med slike filer. Imidlertid presenteres innholdet i *.xlsx- og *.docx-filene i OOXML-standarden, det vil si at det virkelige, forståelige dokumentet presenteres i et zip-arkiv. Et Zip-arkiv er et sett med filer, inkludert bilder, objekter, formler og innlegg fra andre programmer. Tekstfiler her er representert med beskrivelser i form av tagger. Å lese en slik fil er ikke nok; du må analysere den for å få innholdet og strukturen for bruk og modifikasjon.

Dette betyr at leseoperasjonen blir til en arkivåpningsprosedyre. Disse bibliotekene åpner dokumentarkivet uavhengig og gir utvikleren omfattende funksjoner for å lese, behandle og skrive slike dokumenter.

Excel-tabeller

include_once 'PhpOffice/PhpExcel/IOFactory.php'

funksjon scGetExcelFile($xls)(

$objPHPExcel = PHPExcel_IOFactory::load($xls)

$objPHPExcel->setActiveSheetIndex(0)

//denne matrisen inneholder matriser med strenger

$aSheet = $objPHPExcel->getActiveSheet()

$array = array()

//behandling

foreach($aSheet->getRowIterator() som $row)(

$cellIterator = $row->getCellIterator()

foreach($cellIterator som $cell)(

array_push($item, iconv("utf-8", "cp1251", $cell->getCalculatedValue()))

array_push($array, $item)

Å lese og behandle Excel-filer er mye vanskeligere enn å behandle Word-dokumenter. Det beste alternativet, hvis du trenger å implementere et seriøst prosjekt for å lese og behandle anvendt informasjon, er først å mestre PHPWord-biblioteket. Dette vil gi deg god erfaring og en rask forståelse av det konkrete problemet.

Word-dokumenter

Bare to linjer:

$oWord = ny \PhpOffice\PhpWord\PhpWord()

$oDocx = $this->oWord->loadTemplate($cFileName)

$cFileName-dokumentet er nå tilgjengelig for behandling. Deretter åpnes arkivet, innholdet velges og analyseres, som kan vises på nettsiden, endres og skrives tilbake.

$zipClass = new ZipArchive()

$zipClass->open($this->tempFileName)

// les hele innholdet i dokumentet

for ($i=0; $i<$zipClass->numFiles; $i++) (

$cNameIn = $zipClass->getNameIndex($i)

$cNameInExt = substr($cNameIn, -4)

if (($cNameInExt == ".xml") || ($cNameInExt == "rels")) (

// filer med filtypene ".xml" og ".xml.rels" lagres i dokumenttabellen

// hver xml-linje skrives med et unikt nummer i rekkefølge

$cBodyIn = $zipClass->getFromName($cNameIn)

$cBodyInLen = strlen($cBodyIn)

// alle andre filer skrives til dokumentmappen som den er

$cNameOnly = substr($cNameIn, strrpos($cNameIn, "/") + 1)

$zipClass->getFromName($cNameIn, $cWorkPath); // innhold som en fil

Mulighetene som tilbys av PHP Excel og PHP Word lar deg manipulere ekte dokumenter og gjøre innholdet deres relevant til enhver tid. I dagens dynamiske verden blir dette veldig viktig. Tyngdepunktet har lenge flyttet seg fra lokal bruk av datateknologi til det virtuelle internettrommet. Derfor er det mindre effektivt å lage tabeller og dokumenter i lokale Microsoft-produkter enn å arbeide med slike dokumenter i automatisk og halvautomatisk modus på et nettsted, som ikke bare er tilgjengelig for skaperen av tabellen eller dokumentet, men også for forbrukerne.

Tekstfiler, et annet liv

Til en første tilnærming er tekstfiler enklere enn PHP-filer eller applikasjonsdokumenter. Det er imidlertid noe å tenke på her. Lese-/skriveoperasjonene til slike filer er allerede angitt ovenfor, men betydningen av slike filer er mye viktigere.

Siden det er en gitt som en klient og en server (den første er dominert av JavaScript, den andre av PHP), så kan ikke selv mekanismene for informasjonskapsler og økter takle behovet for å overføre informasjon mellom skript, sider eller visse prosesser.

Det er mulig å reflektere de ønskede endringene i databasen, men for alle fordelene og hastigheten kan små midlertidige eller permanente tekstfiler være et mye mer interessant alternativ for å overføre informasjon. Hvis du ikke lager mange små filer og kontrollerer størrelsen deres, kan de være en spesifikk og mer fleksibel versjon av en database.

PHP-lesing av en tekstfil er rask, den kan umiddelbart analyseres til en struktur, array eller objekt. Det siste er veldig viktig, siden det lar deg lage objekter som lever utenfor tiden som er tildelt et PHP-skript, som, som du vet, bare kan eksistere på serveren, og bare i det øyeblikket siden er lastet, er et AJAX-svar generert, eller av en annen grunn som får PHP-tolken til å starte.

Hvis du tenker på det faktum at en tekstfil er innholdet og strukturen fra utvikleren, er en PHP-fil syntaksen til tolken pluss utviklerens logikk, og "taggede" beskrivelser html, css, xml er mer semantiske elementer, men regulert etter statiske standarder. Man kan komme til den konklusjon at det sannsynligvis er på tide at filene får nytt innhold, og dette bør i seg selv bestemme kvaliteten og brukslogikken. Det er nettopp fordi programmering ennå ikke er klar for neste utviklingsstadium at filer i dag forblir ganske enkelt filer som utvikleren oppretter og bestemmer bruken av dem.

Det mest interessante og lovende er når PHP leser en PHP-fil uavhengig når behovet oppstår. Og en enkel PHP-lesing av en linje fra en fil resulterer i opprettelsen av et objekt, i det minste i den tilstanden det ble lagret i. Dette er ikke helt kjente ideer, men i den moderne verden endres alt så raskt.

streng fgets(ressurshåndtak [, int lengde])

Returnerer en streng med lengde - 1 byte lest fra filbeskrivelsen pekt på av håndtaket. Lesingen slutter når antall leste byte når lengden - 1, når den når slutten av linjen (som er inkludert i returverdien), eller når den når slutten av filen (det som kommer først). Hvis lengden ikke er spesifisert, er standarden 1 kilobyte eller 1024 byte.

Hvis det oppstår en feil, returnerer funksjonen FALSK .

De vanligste feilene:

Programmerere som er vant til semantikken til "C"-funksjoner fgets(), må ta hensyn til forskjellen i hvordan end-of-file (EOF)-flagget returneres.

Filpekeren må være gyldig og peke til en fil som ble åpnet av funksjonene fopen() eller fsockopen() .

Nedenfor er et enkelt eksempel:

Eksempel 1. Lese en fil linje for linje $handle = fopen("/tmp/inputfile.txt" , "r" ); mens (! feof ($handle )) ( $buffer = fgets($handle, 4096); ekko $buffer ; } fclose($handle); ?>

Kommentar: Lengdeparameteren ble valgfri fra og med PHP versjon 4.2.0. Hvis denne parameteren utelates, antas lengden på strengen å være 1024. Fra og med PHP 4.3 vil utelatelse av lengdeparameteren føre til at strømmen leses til slutten av strengen. Hvis de fleste linjene i filen er lengre enn 8 kilobyte, er den mest effektive avgjørelsen angående ressursene som brukes av skriptet å spesifisere en maksimal linjelengde.

Kommentar: Denne funksjonen kan behandle binære data korrekt fra PHP 4.3. Tidligere versjoner hadde ikke denne funksjonaliteten.

18,4K

Faktisk, hvordan åpne en php-fil er ikke et stort problem. Det kan være vanskeligere å åpne en flaske øl når du er midt i en skog. Men bare ivrige programmerere tenker på denne måten. Og for nybegynnere vil vi fortelle deg om alle funksjonene til PHP for å jobbe med filer:

php-filer

Filer med filtypen php inneholder kode skrevet i programmeringsspråket med samme navn. I motsetning til andre språk, er php et programmeringsspråk på serversiden. Det vil si at den kjører på serversiden. Derfor, for å feilsøke koden, må en lokal server installeres på klientmaskinen.

For å jobbe med php-filer brukes spesielle applikasjoner - programvareredigerere. De vanligste er:

• Dreamweaver.
• PHPEdit.
• Eclipse PHP-utvikling.

Når du lager nettsider basert på PHP, må du kanskje gjenbruke programkode. I slike situasjoner er det praktisk å koble til ferdige løsninger som ligger i en annen fil. Inkluderingskonstruksjonen brukes til dette. Syntaksen er:

inkludere filnavn

Eksempel på tilkobling:

Inkludert fil:

Det er også mulig å inkludere en fil ved å bruke require-konstruksjonen. I motsetning til include, inkluderer den filen før programkoden kjøres. Ved å bruke require i koden er kun ett kall til denne filen mulig. Når det åpnes igjen, vil systemet vise en global feilmelding og stoppe programkjøringen.

Inkluderingskonstruksjonen inkluderer bare kilden under programkjøring. Den støtter flere lesing av php-fil. Hvis det oppstår en feil, vil bare en advarsel vises, og kjøring av kode vil fortsette fra neste linje.

Åpne og lukke filer

I php utføres alle operasjoner med filer i flere stadier:

• Åpne en fil;
• Innholdsredigering;
• Lukker filen.

Fopen()-funksjonen brukes til å åpne en fil. Syntaksen er:

int fopen(streng filnavn, strengmodus [, int use_include_path])

Aksepterte argumenter:

• streng filnavn – filnavn eller absolutt bane til den. Hvis banen til filen ikke er spesifisert, vil den bli søkt i gjeldende katalog. Hvis filen du leter etter mangler, vil systemet vise en feilmelding. Eksempel:

• strengmodus – indikerer filåpningsmodus. Verdier akseptert av argumentet:

• r – filen åpnes kun for lesing, filpekeren er satt i begynnelsen;
• r+ – filen er åpen for lesing og skriving;
• w – oppretter en ny fil kun for skriving. Hvis en fil med samme navn allerede eksisterer, slettes alle data i den automatisk;
• w+ - oppretter en ny fil for skriving og lesing. Når en slik fil eksisterer, blir dataene fullstendig overskrevet med nye;
• a – filen er åpen for skriving. Pekeren settes på slutten. Det vil si at skriving til php-filen starter ikke fra begynnelsen, men fra slutten;
• a+ – åpne en fil i lese-skrivemodus. Opptaket vil starte fra slutten;
• b – arbeidsmåte med en fil som inneholder binære data (i det binære tallsystemet). Denne modusen er bare tilgjengelig på Windows-operativsystemet.

For å lukke tilgangen til en fil, bruk fclose()-funksjonen. Syntaks:

int fclose (int-fil) , der int-fil er et håndtak til nettstedet som skal lukkes.

Etter hver lesing eller skriving må filen lukkes med denne funksjonen. Ellers forblir strømmen som er opprettet for filen åpen. Og dette fører til unødvendig forbruk av serverkapasitet.

Eksempel:

Lese og skrive filer

For ganske enkelt å vise hele innholdet i en fil, er funksjonen readfile() ideell. Syntaksen er:

readfile (strengfilnavn) , der strengfilnavn er strengfilnavnet (ikke et håndtak).

Den samme filen kan leses ved å bruke fpassthru()-funksjonen. Den leser data fra sluttpekerposisjonen til slutten av filen. Syntaksen er:

int fpassthru (int-fil)

Funksjonen krever åpning og lukking av en fil. Eksempel:

Resultatet er likt det forrige.

Funksjoner for å jobbe med filer i php lar deg lese innhold linje for linje og tegn for tegn:

• streng fgets (int-fil, int-lengde)– funksjonen leser en streng med lengdelengde . Eksempel:

• streng fread (int fil, int lengde)– handlingen er identisk med den forrige.

For å skrive tekstdata til en fil, er det to identiske funksjoner:

• int fputs (int-fil, strengstreng [, int lengde ])
• int fwrite(int fil, strengstreng [, int lengde])

Funksjonene skriver til en fil int-fil en strengstreng med den angitte lengden int lengde ( valgfritt argument). Eksempel:

Opprette og slette filer

For å lage en php-fil kan du bruke fopen()-funksjonen i "w" eller "w+" tilgangsmodus. Eller touch()-funksjonen. Den angir filendringens tid. Hvis det ikke er noe element med det søkte navnet, vil det bli opprettet. Dens syntaks.

Sist oppdatert: 1.11.2015

Som de fleste programmeringsspråk, støtter PHP arbeid med filer, som er en av måtene å lagre informasjon på.

Lese og skrive filer

Åpne og lukke filer

For å åpne filer i PHP, er fopen()-funksjonen definert. Den har følgende definisjon: ressurs fopen(streng $filnavn, streng $modus) . Den første $filename-parameteren representerer banen til filen, og den andre er åpningsmodusen. Avhengig av formålet med å åpne og typen fil, kan denne parameteren ha følgende verdier:

"r" : Filen åpnes skrivebeskyttet. Hvis filen ikke eksisterer, returnerer false

"r+" : Filen åpnes skrivebeskyttet og skrivbar. Hvis filen ikke eksisterer, returnerer false

"w" : Filen åpnes for skriving. Hvis en slik fil allerede eksisterer, blir den overskrevet, hvis ikke, blir den opprettet.

"w+" : Filen åpnes for skriving og lesbar. Hvis en slik fil allerede eksisterer, blir den overskrevet, hvis ikke, blir den opprettet.

"a" : Filen åpnes for skriving. Hvis en slik fil allerede eksisterer, skrives dataene til slutten av filen, og de gamle dataene forblir. Hvis filen ikke eksisterer, opprettes den

"a+" : Filen åpnes for lesing og skriving. Hvis filen allerede eksisterer, blir dataene lagt til på slutten av filen. Hvis filen ikke eksisterer, opprettes den

Utdata fra fopen-funksjonen vil være en filbeskrivelse. Dette håndtaket brukes til filoperasjoner og for å lukke filen.

Etter endt arbeid, må filen lukkes ved å bruke funksjonen fclose(), som tar en filbeskrivelse som parameter. La oss for eksempel åpne og lukke en fil:

$fd = fopen("form.php", "r") eller die("kunne ikke åpne filen"); fclose($fd);

Konstruksjonen or die ("feiltekst") lar skriptet slutte å kjøre og vise en feilmelding hvis fopen-funksjonen ikke var i stand til å åpne filen.

Leser en fil

Du kan bruke flere funksjoner for å lese en fil. For linje-for-linje-lesing brukes fgets()-funksjonen, som mottar en filbeskrivelse og returnerer én lest linje. La oss gå gjennom hele filen linje for linje:

Hver gang fgets() kalles, vil PHP plassere pekeren på slutten av den leste linjen. For å spore slutten av en fil, brukes feof()-funksjonen, som returnerer true når filen er fullført. Og til slutten av filen er nådd, kan vi bruke funksjonen fgets().

Leser hele filen

I dette tilfellet trenger vi ikke eksplisitt å åpne filen, få et håndtak og deretter lukke filen.

Blokker lesing

Du kan også lese blokk-for-blokk, det vil si lese et visst antall byte fra en fil ved å bruke fread()-funksjonen:

Fread()-funksjonen tar to parametere: filhåndtaket for å lese og antall byte som skal leses. Når en blokk leses, flyttes pekeren i filen til slutten av blokken. Og også ved å bruke feof()-funksjonen kan du spore fullføringen av en fil.

Skriv en fil

For å skrive en fil, bruk fwrite()-funksjonen, som skriver følgende linje til filen:

En annen fputs()-funksjon fungerer på samme måte:

Arbeider med filpekeren

Når du åpner en fil for lesing eller skriving i "w"-modus, plasseres pekeren i filen i begynnelsen. Når du leser data, flytter PHP pekeren i filen til slutten av blokken med data som ble lest. Imidlertid kan vi også manuelt manipulere pekeren i filen og sette den til en vilkårlig plassering. For å gjøre dette må du bruke funksjonen fseek, som har følgende formelle definisjon:

Int fseek (ressurs $handle , int $offset [, int $whence = SEEK_SET ])

$handle-parameteren representerer et filhåndtak. $offset-parameteren er offset i byte i forhold til begynnelsen av filen som lesing/skriving vil begynne fra. Den tredje valgfrie parameteren spesifiserer hvordan forskyvningen settes. Det kan ha tre verdier:

SEEK_SET : standardverdi, setter forskyvningen i offsetbyte i forhold til starten av filen

SEEK_CUR : setter forskyvningen i offsetbyte i forhold til begynnelsen av gjeldende posisjon i filen

SEEK_END : setter forskyvningen til å forskyve byte fra slutten av filen

Hvis pekeren er vellykket installert, returnerer fseek()-funksjonen 0, og hvis pekeren ikke lykkes, returnerer den -1.

Eksempel på bruk av funksjonen:

$fd = fopen("hello.txt", "w+") eller die("kunne ikke åpne filen"); $str = "Hei verden!"; // linje for å skrive fwrite($fd, $str); // skriv linjen til begynnelsen fseek($fd, 0); // plasser filpekeren i begynnelsen fwrite($fd, "Oink"); // skriv linjen i begynnelsen fseek($fd, 0, SEEK_END); // plasser pekeren på slutten fwrite($fd, $str); // skriv en annen linje på slutten fclose($fd);