PHP

file_exists("test.txt")//Finns filen? filesize("test.txt");//Ta reda på filstorleken //Tidsstämpeln returneras: fileatime("test.txt");//Datum för senaste åtkomst till filen //date("d M Y" , $atime); filemtime("test.txt");//Datum för filändring //date("d M Y", $mtime); filectime("test.txt");//Datum då filen skapades (Windows) //date("d M Y", $ctime);

Filer: driftlägen

PHP

resurs fopen (sträng filnamn, strängläge) // resurs - returnerar en pekare till filen vid framgång, eller FALSK vid fel

Driftläge	Beskrivning
r	öppen fil skrivskyddad;
r+	öppna filen för att läsa och skriva;
w	öppna filen endast för skrivning. Om det finns, förstörs det aktuella innehållet i filen. Den aktuella positionen är inställd på början;
w+	öppna filen för att läsa och skriva. Om det finns, förstörs det aktuella innehållet i filen. Den aktuella positionen är inställd på början;
A	öppna filen för skrivning. Den aktuella positionen är inställd på slutet av filen;
a+	öppna filen för att läsa och skriva. Den aktuella positionen är inställd på slutet av filen;
b	bearbeta den binära filen. Denna flagga krävs när du arbetar med binära filer på Windows.

Öppna och stänga filer i PHP

PHP

$fi = fopen("test.html", "w+") eller die("Fel"); //Exempel $fi = fopen("http://www.you/test.html","r"); $fi = fopen("http://ftp.you/test.html", "r"); //Stäng fclose($fi)

Läser filer i PHP

PHP

//Läs filen fread(int fi, int length) $str = fread($fi, 5); // Läs de första 5 tecknen echo $str; // eftersom markören har flyttat $str = fread($fi, 12); // Läs nästa 12 tecken echo $str; fgets(int fi[, int length]) // Läs en rad från en fil fgetss(int fi, int length [, sträng tillåten]) // Läs en rad från en fil och kassera HTML-taggar // sträng tillåten - taggar som måste lämnas fgetc(int fi) //Läser ett tecken från en fil

Initialt kommer skrivningen att ske i början av filen, genom att skriva över befintlig data, om någon. Därför, om du behöver skriva något i slutet av filen, måste du ställa in lämpligt läsläge, till exempel, a+ .

Markörmanipulation i PHP-filer

PHP

int fseek(int fi, int offset [, int varifrån]) //Ställa in markören // int fi - pekare till filen //offset - antal tecken som ska flyttas. //varifrån: //SEEK_SET - rörelsen börjar från början av filen; //SEEK_CUR - rörelse startar från den aktuella positionen; //SEEK_END - rörelsen börjar från slutet av filen. fseek($fi, -10, SEEK_END); //Läs de sista 10 tecknen $s = fread($fi, 10); $pos = ftell($fi); //Ta reda på den aktuella positionen spola tillbaka($f)//återställ markören bool feof($f) //slut på filen

Direktarbete med filer (data) i PHP

PHP

array file(string filename) // Hämta innehållet i filen i form av en array // Ett annat alternativ för att direkt arbeta med data file_get_contents(string filename) // Läsa (få hela filen på en rad) // Skriva till filen (ursprungligen överskriven) file_put_contents(sträng filnamn, blandad data[,int flagga]); //FILE_APPEND // Skriv till slutet av filen: file_put_contents("test.txt", "data", FILE_APPEND); //Om du skriver en array, $array = array("I", "live"); file_put_contents("test.txt",$array); //då får vi "Ilive"

Hantera filer i php

PHP

copy(strängkälla, strängdestination); // Kopiera filen rename(str oldname, str newname); // Byt namn på filen unlink(sträng filnamn); // Ta bort en fil

Ladda upp filer till PHP-servern

//PHP.ini-inställningar file_uploads (på|av) // tillåt eller tillåt filuppladdning upload_tmp_dir // temporär mapp för uppladdade filer. som standard temporär mapp upload_max_filesize (standard = 2 Mb) // max. ladda upp filstorlek post_max_size // totala storleken på det inskickade formuläret (måste vara större än upload_max_filesize) // Enkel uppladdning

HTML

Arbeta med filer på servern

PHP

//Acceptera data $tmp = $_FILES["användarfil"]["tmp_name"]; $namn = $_FILES["användarfil"]["namn"]; //Flytta filen move_uploaded_file($tmp, namn); move_uploaded_file($tmp, "upload/".name); // omdirigera filen till uppladdningsmappen // i förhållande till den aktuella filen // Vad finns i $_FILES-matrisen $_FILES["användarfil"]["namn"] // filnamn, till exempel test.html $_FILES[ "userfile"][" tmp_name"] // temporärt filnamn (sökväg) $_FILES["userfile"]["size"] // filstorlek $_FILES["userfile"]["typ"] // filtyp $ _FILES["användarfil"] ["fel"] // 0 - inga fel, nummer - ja sträng fgets(resurshandtag [, int längd])

Returnerar en sträng med längden - 1 byte läs från filbeskrivningen som pekas på av handtaget. Läsningen slutar när antalet lästa byte når längden - 1, när det når slutet av raden (som ingår i returvärdet), eller när det når slutet av filen (beroende på vilket som kommer först). Om längden inte anges, är den som standard 1 kilobyte eller 1024 byte.

Om ett fel uppstår kommer funktionen tillbaka FALSK .

De vanligaste misstagen:

Programmerare som är vana vid semantiken för "C"-funktioner fgets(), måste ta hänsyn till skillnaden i hur end-of-file (EOF)-flaggan returneras.

Filpekaren måste vara giltig och peka på en fil som framgångsrikt öppnats av funktionerna fopen() eller fsockopen() .

Nedan följer ett enkelt exempel:

Exempel 1. Läsa en fil rad för rad $handle = fopen("/tmp/inputfile.txt" , "r" ); while (! feof ($handle )) ( $buffert = fgets($handle, 4096); echo $buffert ; } fclose($handtag); ?>

Kommentar: Längdparametern blev valfri från och med PHP version 4.2.0. Om denna parameter utelämnas, antas längden på strängen vara 1024. Från och med PHP 4.3, kommer utelämnande av längdparametern att göra att strömmen läses till slutet av strängen. Om de flesta raderna i filen är längre än 8 kilobyte är det mest effektiva beslutet angående resurserna som används av skriptet att ange en maximal radlängd.

Kommentar: Denna funktion kan korrekt bearbeta binära data från PHP 4.3. Tidigare versioner hade inte denna funktionalitet.

Om att använda funktionerna fopen, fclose, feof, fgets, fgetss och fscanf

Låt oss lista alla möjligheter

En av fördelarna med att arbeta med moderna programmeringsspråk som PHP är antalet tillgängliga funktioner. PHP skulle lätt kunna anta Perls motto, "Det finns mer än ett sätt att göra något", särskilt när det kommer till filbehandling. Men med de många tillgängliga verktygen blir frågan vilken som är bäst för att få jobbet gjort. Naturligtvis beror svaret på denna fråga verkligen på vad dina mål är när du bearbetar filen, så att lära sig alla språkets kapacitet är värt din tid.

Traditionella fopenmetoder

Fopen-metoderna är kanske de mest bekanta för tidigare C- och C++-programmerare, eftersom de mer eller mindre är verktygen som har funnits till hands i flera år om du har arbetat med dessa programmeringsspråk. För någon av dessa metoder följer du standardproceduren, använder fopen för att öppna filen, en funktion för att läsa data och sedan fclose för att stänga filen, som visas i Lista 1.

Lista 1. Öppna och läsa en fil med fgets

$file_handle = fopen("minfil", "r"); while (!feof($file_handle)) ( $line = fgets($file_handle); echo $line; ) fclose($file_handle);

Även om dessa funktioner är bekanta för de flesta erfarna programmerare, låt mig analysera hur de fungerar. I verkligheten följer du dessa steg:

1. Öppna filen. $file_handle lagrar en länk till själva filen.
2. Kontrollera om du har nått slutet av filen.
3. Fortsätt läsa filen tills du kommer till slutet, skriv ut varje rad du läser.
4. Stäng filen.

Med det i åtanke kommer jag att titta på varje filfunktion som används här.

fopen funktion

Fopen-funktionen upprättar en anslutning till en fil. Jag säger "etablerar en anslutning" eftersom fopen förutom att öppna en fil också kan öppna en URL:

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

Denna programrad skapar en länk till sidan ovan och låter dig börja läsa den som en lokal fil.

Notera: Alternativet "r" som används i fopen indikerar att filen är öppen skrivskyddad. Eftersom att skriva till en fil inte ingår i omfattningen av frågor som diskuteras i den här artikeln kommer jag inte att lista alla möjliga värden för parametern. Du måste dock ändra "r" till "rb" om du läser från binärer för plattformsoberoende kompatibilitet. Nedan är ett exempel på denna typ.

feof funktion

Feof-kommandot avgör om läsningen har nått slutet av filen och returnerar True eller False. Slingan som visas i fortsätter till slutet av filen "minfil". Observera att feof också returnerar False om du läser en URL och anslutningen timeout eftersom det inte finns mer data att läsa.

Funktion fstäng

Låt oss hoppa över mitten av lista 1 och gå till slutet; fclose gör motsatsen till fopen: den stänger anslutningen till filen eller URL:en. Efter att ha utfört denna funktion kommer du inte längre att kunna läsa från filen eller sockeln.

fgets funktion

Om du går tillbaka några rader i Lista 1 kommer du till kärnan i filbearbetningsprocessen: att faktiskt läsa filen. Fgets-funktionen är ditt val av vapen i det första exemplet. Den tar en rad data från en fil och returnerar den som en sträng. Därifrån kan du visa data eller på annat sätt bearbeta den. Exemplet i Lista 1 skriver ut hela filen.

Om du bestämmer dig för att begränsa storleken på databiten du arbetar med kan du lägga till ett fgets-argument för att begränsa den maximala längden på datasträngen som fångas. Använd till exempel följande kod för att begränsa längden på en rad till 80 tecken:

$string = fgets($file_handle, 81);

Tänk på "\0", radens slutindikator i C, och ställ in längden till ett tecken längre än du faktiskt behöver. Som du kan se använder exemplet ovan 81, medan du behöver 80 tecken. Gör det till en vana att lägga till ett extra tecken när du behöver ställa in en radlängdsgräns för en given funktion.

fread funktion

Funktionen fgets är bara en av många tillgängliga funktioner för att läsa en fil. Detta är en av de mest använda funktionerna, eftersom bearbetning av en fil rad för rad i de flesta fall är mest meningsfullt. Faktum är att flera andra funktioner erbjuder liknande möjligheter. Hur som helst, rad för rad analys är inte alltid vad du behöver.

Och här kommer vi åt fread . Fread-funktionen har ett något annat syfte än fgets: den är tänkt att läsa från binära filer (det vill säga filer som initialt inte består av läsbar text). Eftersom begreppet "linjer" inte är relevant för binära filer (logiska datastrukturer är vanligtvis inte uppdelade i rader), måste du ange antalet byte som ska läsas.

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

Exemplet ovan läser 4096 byte (4 KB) data. Observera att, oavsett vilket värde du anger, kommer fread att läsa maximalt 8192 byte (8 KB).

Förutsatt att filen inte är större än 8 KB, bör programavsnittet nedan läsa hela filen på en rad.

$fh = fopen("minfil", "rb"); $data = fread($fh, filstorlek("minfil")); fclose($fh);

Om filstorleken är större måste du använda en slinga för att läsa resten av den.

fscanf-funktion

För att komma tillbaka till strängbehandling, är fscanf också efterföljaren till den traditionella filbiblioteksfunktionen i C. Om du inte är bekant med den läser fscanf datafält till variabler från en fil.

list ($field1, $field2, $field3) = fscanf($fh, "%s %s %s");

Formatsträngarna som används i den här funktionen beskrivs i många källor som PHP.net, så jag kommer inte att upprepa denna information här. Det räcker med att säga att strängformatering är mycket flexibel. Det bör också nämnas att alla fält placeras i variabeln som returneras av funktionen. (I C skulle dessa skickas som argument.)

fgetss funktion

Funktionen fgetss skiljer sig från traditionella filmanipuleringsfunktioner och ger dig en bättre förståelse för PHPs möjligheter. Det fungerar som fgets, men kasserar alla HTML- eller PHP-taggar som den upptäcker, och lämnar bara den blotta texten. Låt oss ta HTML-filen nedan.

Lista 2. Exempel HTML-fil

Om du förstår vad "Cause there ain"t no one for to give you no pain" betyder så lyssnar du för mycket på bandet America

Låt oss skicka det genom fgetss-funktionen.

Lista 3. Använda fgetss

$file_handle = fopen("minfil", "r"); while (!feof($fil_handtag)) ( echo = fgetss($fil_handtag); ) fclose($fil_handtag);

Detta är vad du får som utdata:

Min titel Om du förstår vad "Cause there ain"t no one for to give you no pain" betyder så lyssnar du för mycket på bandet America

fpassthru-funktion

Oavsett hur du läser data från en fil kan du skriva ut återstående data med hjälp av standardutgångskanalen med fpassthru-funktionen.

fpassthru($fh);

Denna funktion skriver ut data så att du inte behöver lägga in den i en variabel.

Icke-linjär filbehandling: flytta genom en fil

Funktionerna som beskrivs ovan låter dig naturligtvis bara läsa från en fil sekventiellt. Mer komplexa filer kan kräva att du flyttar till olika delar av filen i början eller slutet av filen. För att göra detta behöver du funktionen fseek.

fseek($fh, 0);

Exemplet ovan går tillbaka till början av filen. Om du inte vill flytta till början av filen - säg att en kilobyte räcker - skriver du helt enkelt:

fseek($fh, 1024);

Från och med PHP V4.0 finns flera andra alternativ också tillgängliga. Till exempel, om du behöver flytta framåt 100 byte från din nuvarande position, kan du använda följande kod:

fseek($fh, 100, SEEK_CUR);

På samma sätt går tillbaka 100 byte genom att:

fseek($fh, -100, SEEK_CUR);

Om du vill gå tillbaka till 100 byte-positionen före slutet av filen, använd SEEK_END istället.

fseek($fh, -100, SEEK_END);

När den nya positionen har nåtts kan du använda fgets, fscanf eller en annan funktion för att läsa data.

Notera: du kan inte använda fseek på filbeskrivningar som refererar till en URL.

Fånga en hel fil

Nu går vi vidare och tittar på några av PHPs unika filbehandlingsmöjligheter: bearbetning av stora datablock på en eller två rader. Hur kan du till exempel ta tag i en fil och visa hela dess innehåll på din webbsida? Tja, du har sett ett exempel på att använda en loop med fgets. Men hur kan du göra det lättare? Processen är nästan löjligt enkel med hjälp av fgetcontents, som lägger hela filen på en rad.

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

Även om detta inte är det bästa alternativet, kan du skriva det här kommandot ännu kortare:

echo file_get_contents("mittfilnamn");

Den här artikeln fokuserar främst på att bearbeta lokala filer, men det är värt att notera att du även kan fånga, visa och analysera andra webbsidor med de funktioner som beskrivs.

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

Detta kommando är faktiskt detsamma som:

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

Du kanske tittar på dessa exempel och tänker: "Det är mycket arbete." PHP-utvecklare håller med dig. Så du kan förkorta kommandot ovan till:

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

Readfile-funktionen matar ut hela innehållet i en fil eller webbsida till standardutgångsbufferten. Som standard visar detta kommando ett felmeddelande när det misslyckas. För att undvika detta beteende (om du vill det), prova kommandot:

@läsfil("http://127.0.0.1/");

Naturligtvis, om du behöver bearbeta innehållet i filer, är den enda raden som returneras av file_get_contents förmodligen för mycket. Du kanske vill först dela upp den i delar med hjälp av split()-funktionen.

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

Men varför behöver du all denna komplexitet om det finns en perfekt passande funktion som kommer att göra jobbet åt dig? PHP file()-funktionen utför denna uppgift i ett steg: den returnerar en strängarray vars element är raderna i filen.

$array = fil("minfil");

Det bör noteras att det finns en liten skillnad mellan de två exemplen ovan. Split-kommandot tar bort newlines, medan file-kommandot avslutar array-raderna med newlines (liksom fgets).

PHPs möjligheter går dock långt utöver de som beskrivs ovan. Du kan analysera hela .ini-filer i PHP-stil med bara ett parse_ini_file-kommando. Kommandot parse_ini_file gäller filer som liknar de som visas i Lista 4.

Lista 4. Exempel .ini-fil

; Kommentarsnamn = "Kung Arthur"-uppdrag = Att söka den heliga gralens favoritfärg = Blå Samuel Clemens = Mark Twain Caryn Johnson = Whoopi Goldberg

Följande kommandon representerar en fil som en array och skriv sedan ut arrayen:

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

Resultatet blir följande utdata:

Lista 5. Utgång

Array ( => Kung Arthur => Att söka den heliga gralen => Blå => Mark Twain => Whoopi Goldberg)

Naturligtvis kan du märka att detta kommando har slagit samman sektionerna. Detta är standardåtgärden, men du kan enkelt anpassa den genom att använda det andra argumentet för parse_ini_file: process_sections, som är en boolesk variabel. Ställ in process_sections till True.

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

Och din utdata kommer att se ut så här:

Lista 6. Utgång

Array ( => Array ( => King Arthur => Att söka den heliga gralen => Blue) => Array ( => Mark Twain => Whoopi Goldberg))

PHP placerar data i en lätt parserbar flerdimensionell array.

Men detta är bara toppen av isberget när det kommer till filbehandling i PHP. Mer komplexa funktioner som tidy_parse_file och xml_parse kan hjälpa dig att analysera HTML- respektive XML-dokument. Se avsnittet för mer detaljerad information om hur dessa funktioner fungerar. Båda dessa är värda att överväga om du kommer att arbeta med dessa filtyper, men istället för att gå igenom alla möjliga filtyper, kanske du vill ta en närmare titt på innehållet i den här artikeln, som har några bra allmänna regler för arbetar med de funktioner jag har beskrivit hittills.

Bra programmeringsstil

Utgå aldrig från att allt i ditt program kommer att fungera som det är tänkt. Till exempel: vad händer om filen du letar efter har flyttats? Vad händer om en behörighetsändring gör att du inte kan läsa innehållet i en fil? Du kan kontrollera existensen av en fil och rättigheterna att läsa den i förväg med metoderna file_exists och is_readable.

Lista 7. Att använda file_exists och is_readable

$filnamn = "minfil"; if (fil_exists($filnamn) && är_läsbar ($filnamn)) ( $fh = fopen($filnamn, "r"); # Bearbetar fclose($fh); )

Men i praktiken kommer detta program förmodligen att vara överdrivet för din uppgift. Att hantera värdena som returneras av fopen är enklare och mer exakt.

if ($fh = fopen($filnamn, "r")) ( # Bearbetar fclose($fh); )

Eftersom fopen returnerar False om det misslyckas, kommer detta att säkerställa att filen endast kommer att behandlas om filen kan öppnas. Naturligtvis, om filen inte finns eller är oläsbar, förväntar du dig att returvärdet är negativt. Därför är en sådan kontroll en fälla som alla potentiella problem hamnar i. Alternativt kan du avsluta programmet eller visa ett felmeddelande om filen inte kan öppnas.

Precis som fopen returnerar funktionerna file_get_contents, file och readfile False om filen inte kan öppnas eller bearbetas. Funktionerna fgets, fgetss, fread, fscanf och fclose returnerar också False om ett fel uppstår. Naturligtvis, med undantag för fclose , har du förmodligen redan bearbetat resultaten de returnerar. När det gäller fclose , det finns inte mycket som kan göras om filhandtaget inte stängs ordentligt, så att kontrollera returvärdet för fclose är i allmänhet överdrivet.

Valet är ditt

PHP har ingen brist på effektiva sätt att läsa och analysera filer. Klassiska funktioner som fread kan tjäna dig tillförlitligt för det mesta, eller så kan du vara mer attraherad av enkelheten i readfile om det är vad du behöver för att få jobbet gjort. Valet beror verkligen på vad du försöker åstadkomma.

Om du bearbetar stora mängder data, kommer du sannolikt att tycka att fscanf är mer användbart och effektivt än att till exempel använda fil i kombination med de efterföljande kommandona split och sprintf. Om du bara visar en stor mängd text med mindre ändringar kan det dock vara mer meningsfullt att använda funktionerna file , file_get_contents eller readfile. Denna lösning kommer förmodligen att vara korrekt när du använder PHP för att cachelagra eller till och med skapa en tillfällig proxyserver.

PHP tillhandahåller många verktyg för att arbeta med filer. Lär känna var och en bättre och ta reda på vilka verktyg som är bäst för det projekt du arbetar med. Du erbjuds ett brett urval av mjukvaruverktyg, använd dem mest effektivt och ha kul med att bearbeta dina filer med PHP.

I PHP måste du ofta ta itu med att skapa en fil... det är väldigt enkelt: det finns ingen fil på disken, koden kördes och filen dök upp, sedan kan du läsa in den här filen till en annan variabel eller till och med vilken sida som helst på Internet och skriv sedan något där... men för detta behöver du känna till specialfunktioner... mer om det i den här artikeln...

För att skapa en fil i PHP i ett körbart skript behöver du bara ange några funktioner:

Låt oss ta en titt på ett exempel:

$text = "Någon typ av text att skriva till filen";
$fp = fopen("fil.txt", "w");
fwrite($fp, $text);
fclose($fp);
?>

Här borde du veta:

fopen()- funktionen öppnar filen för läsning eller skrivning och förtydliganden;

Detta förtydligande (modparametern för fopen-funktionen) är mycket viktigt:

• "r" - öppna en fil i php Endast för läsning. Markören placeras i början.
• "r+" - öppna en fil i php för att läsa och skriva. Markören placeras i början. !!! - med dessa två lägen r och r+ måste filerna redan skapas (annars kommer ett fel att visas Varning: fopen(file.txt): kunde inte öppna strömmen: Ingen sådan fil eller katalog i ...), och vi läser bara eller så har vi möjlighet att lägga till.
• "w" - filen öppnas ENDAST för skrivning. Filen trunkeras till noll längd - det vill säga den skrivs över. Det som behövs skrivs och markören placeras i början.
• "w+" - öppnar en fil för skrivning OCH LÄSNING! Resten är samma som i "w"-läget. !!! - i dessa två lägen - om filen inte har skapats - KOMMER ETT FÖRSÖK ATT SKAPA DEN!
• "a" - öppna filen ENDAST för att skriva. Till skillnad från "w" skriver det här alternativet inte över innehållet i filen, utan placerar markören i slutet av raden och lägger till innehållet som vi ville lägga till i slutet.
• "a+" - öppna filen för att skriva och läsa.

fwrite($fp, $text) - en funktion för att skriva till en fil i PHP - det vill säga att det som finns i variabeln $text skrivs till en fil som finns i variabeln $fp;

fstäng($fp) - funktion för att stänga filen som vi skrev till variabeln $fp;

Nu kan du enkelt skapa filer i php korrekt, öppna dem för läsning och redigering.

Användbara PHP-tillägg och funktioner för att arbeta med en öppen fil:

while(!feof($fp))(
$mintext = fgets($fp, 99);
echo $mintext."
";
}

här är villkoret uppfyllt - "tills slutet av filen nås, gör så här" while(!feof($fp))

1. Funktion fgets($fp, 99) - låter dig dela upp allt innehåll i sektioner på 99 byte och längre, för att se detta tydligare placerar vi en tagg

Denna strängfunktion fgets(resurshandtag [, int längd]) accepterar som standard 1024 byte (1 kilobyte) som längdparameter, om den inte anges kommer den att vara så. Denna parameter är valfri från och med PHP 4.2.0 (Returnerar FALSK vid fel)

Ytterligare funktioner för att öppna, skriva och skapa en fil

Funktion - int läsfil(sträng filnamn [, bool use_include_path [, resurskontext]]) - läs filen som helhet.

Läser en fil och skriver innehållet till utdatabufferten. Och returnerar antalet utdata byte. Vid ett fel kommer den tillbaka om hunden inte används - @readfile.

Något liknande kommer att hända:

I slutet av ordet finns en tagg
.

b. Funktion - array fil(sträng filnamn [, int use_include_path [, resurskontext]]), gör samma sak som readfile-funktionen, med ett undantag lägger den till innehållet i filen till en array:

På så sätt kan du läsa alla sidor på Internet: $lines = file("http://site/"); och iterera genom arrayen med hjälp av foreach-funktionen;

3a. strängfunktion file_get_contents(sträng filnamn [, bool use_include_path [, resurskontext [, int offset [, int maxlen]]]] - låter dig få innehållet som en enda sträng.

Detta är en mer universell PHP-funktion för att läsa en fil, liknande filfunktionen, bara innehållet returneras som en sträng, inte en array, och du kan ställa in villkor - vilken byte du ska börja med - offset och var ska man sluta - maxlen. Vid misslyckande kommer den att returnera FALSE.

Viktig!!!- i detta fall ersätter funktionen 3 på en gång: fopen(), fread() och fclose() och blir därmed av med märket.

3b. int funktion file_put_contents(sträng filnamn, blandad data [, int flaggor [, resurskontext]]) - identisk med sekventiella anrop till funktionerna fopen(), fwrite() och fclose() - returnerar antalet skrivna byte.

(PHP 4 >= 4.3.0, PHP 5, PHP 7)

file_get_contents — Läser innehållet i en fil till en sträng

Beskrivning

Sträng file_get_contents (sträng $filnamn [, bool $use_include_path = false [, resurs $kontext [, int $offset = -1 [, int $maxlen ]]]])

Denna funktion liknar funktionen fil() med den enda skillnaden att file_get_contents() returnerar innehållet i filen i en sträng, med början vid den angivna offseten och upp till maxlen byte. Vid misslyckande, file_get_contents() kommer att återvända FALSK.

Använder funktionen file_get_contents() Det är mest att föredra om du behöver få hela innehållet i en fil, eftersom funktionen använder en fil-till-minne-mappningsteknik för att förbättra prestandan, om den stöds av ditt operativsystem.

Kommentar:

Om du öppnar en URI som innehåller specialtecken som blanksteg, måste du koda URI med hjälp av urlencode().

Lista över parametrar

Namnet på filen som läses.

Use_include_path

Kommentar:

Sedan PHP 5 kan du använda konstanten FILE_USE_INCLUDE_PATH för att söka efter en fil i inkluderar sökväg.

sammanhang

En giltig kontextresurs skapad med funktionen stream_context_create(). Om det inte finns något behov av att använda ett speciellt sammanhang kan du hoppa över denna parameter genom att skicka värdet NULL.

Förskjutningen vid vilken läsningen av den ursprungliga strömmen börjar.

Offsetsökning stöds inte när du arbetar med fjärrfiler. Att försöka hitta en offset på icke-lokala filer kan fungera för små offset, men resultatet är oförutsägbart eftersom det körs på en buffrad ström.

Maximal storlek på data som läses. Som standard utförs läsning tills slutet av filen nås. Observera att den här inställningen även gäller för strömmar med filter.

Returvärden

Funktionen returnerar läst data eller FALSK vid fel.

Uppmärksamhet

Denna funktion kan återgå som boolesk FALSK, och ett icke-booleskt värde som gjuts till FALSK. För mer information, se avsnittet Boolean typ. Använd operatorn === för att kontrollera värdet som returneras av denna funktion.

Fel

Ett nivåfel kommer att genereras E_VARNING, om filnamnsparametern inte kan hittas, är parametern maxlength mindre än noll, eller så misslyckas sökningen vid offsetoffset i strömmen.

Exempel

Exempel #1 Hämta och visa källkoden för en webbplatss hemsida

$homepage = file_get_contents("http://www.example.com/");
echo $hemsida ;
?>

Exempel #2 Hitta filer i include_path

// <= PHP 5
$file = file_get_contents("./people.txt" , true );
// > PHP 5
$file = file_get_contents("./people.txt" , FILE_USE_INCLUDE_PATH );
?>

Exempel #3 Läsa ett avsnitt av en fil

// Läs 14 tecken, med början från tecken 21
$section = file_get_contents("./people.txt" , NULL , NULL , 20 , 14 );
var_dump($sektion);
?>

Resultatet av att köra det här exemplet blir ungefär så här:

string(14) "lle Bjori Ro"

Exempel #4 Använda strömmande sammanhang

// Skapa en tråd
$opts = array(
"http" =>array(
"method" => "GET" ,
"header" => "Acceptera-språk: sv\r\n" .
"Cookie: foo=bar\r\n"
);

$context = stream_context_create ($opts);

// Öppna filen med HTTP-rubriken ovan
$fil = file_get_contents ("http://www.example.com/" , false , $context );
?>

Close_notify. PHP kommer att rapportera detta som "SSL: Fatal Protocol Error" så fort du når slutet av data. För att komma runt detta bör du ställa in error_reporting till en nivå som utesluter E_WARNING. PHP-versioner 4.3.7 och äldre kan upptäcka att det finns en problematisk IIS på serversidan när du öppnar en stream med ett omslag https:// och visar ingen varning. Om du använder fsockopen() för att skapa ssl:// socket, är det ditt ansvar att upptäcka och undertrycka denna varning.