Php hur man uttalar. Arbeta med filer i php: öppna, skriva, läsa. Traditionella fopenmetoder

Senaste uppdateringen: 1.11.2015

Liksom de flesta programmeringsspråk stöder PHP arbete med filer, vilket är ett av sätten att lagra information.

Läsa och skriva filer

Öppna och stänga filer

För att öppna filer i PHP, är fopen()-funktionen definierad. Den har följande definition: resurs fopen(sträng $filnamn, sträng $läge) . Den första $filename-parametern representerar sökvägen till filen, och den andra är öppningsläget. Beroende på syftet med att öppna och typen av fil kan denna parameter ha följande värden:

"r" : Filen öppnas skrivskyddad. Om filen inte finns returneras false

"r+" : Filen öppnas skrivskyddad och skrivbar. Om filen inte finns returneras false

"w" : Filen öppnas för skrivning. Om en sådan fil redan finns så skrivs den över, om inte skapas den.

"w+" : Filen är öppen för skrivning och läsbar. Om en sådan fil redan finns så skrivs den över, om inte skapas den.

"a" : Filen öppnas för skrivning. Om en sådan fil redan finns, skrivs data till slutet av filen och den gamla data finns kvar. Om filen inte finns skapas den

"a+" : Filen öppnas för läsning och skrivning. Om filen redan finns läggs data till i slutet av filen. Om filen inte finns skapas den

Utdata från fopen-funktionen kommer att vara en filbeskrivning. Detta handtag används för filoperationer och för att stänga filen.

Efter avslutat arbete måste filen stängas med funktionen fclose() som tar en filbeskrivning som parameter. Låt oss till exempel öppna och stänga en fil:

$fd = fopen("form.php", "r") eller die("kunde inte öppna filen"); fclose($fd);

Konstruktionen or die("error text") tillåter skriptet att sluta köra och visa något felmeddelande om fopen-funktionen inte kunde öppna filen.

Läser en fil

Du kan använda flera funktioner för att läsa en fil. För rad-för-rad-läsning används funktionen fgets(), som tar emot en filbeskrivning och returnerar en rad läst. Låt oss gå igenom hela filen rad för rad:

Varje gång fgets() anropas kommer PHP att placera pekaren i slutet av den lästa raden. För att spåra slutet på en fil används funktionen feof() som returnerar true när filen är klar. Och tills slutet av filen nås kan vi använda funktionen fgets().

Läser hela filen

I det här fallet behöver vi inte explicit öppna filen, skaffa ett handtag och sedan stänga filen.

Blockera läsning

Du kan också göra en block-för-block-läsning, det vill säga läsa ett visst antal byte från en fil med funktionen fread():

Fread()-funktionen tar två parametrar: filhandtaget för att läsa och antalet byte att läsa. När ett block läses flyttas pekaren i filen till slutet av det blocket. Och även med hjälp av feof()-funktionen kan du spåra färdigställandet av en fil.

Skriv en fil

För att skriva en fil, använd funktionen fwrite() som skriver följande rad till filen:

En annan fputs()-funktion fungerar på liknande sätt:

Arbeta med filpekaren

När du öppnar en fil för läsning eller skrivning i "w"-läge, placeras pekaren i filen i början. Vid läsning PHP-data flyttar pekaren i filen till slutet av det lästa datablocket. Men vi kan också manuellt manipulera pekaren i filen och ställa in den på en godtycklig plats. För att göra detta måste du använda funktionen fseek, som har följande formella definition:

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

Parametern $handle representerar ett filhandtag. Parametern $offset är förskjutningen i byte i förhållande till början av filen från vilken läsning/skrivning kommer att börja. Den tredje valfria parametern anger hur offseten ställs in. Det kan ta tre värden:

SEEK_SET : standardvärde, ställer in offset i offsetbyte i förhållande till filens början

SEEK_CUR : ställer in offset i offsetbyte relativt början av den aktuella positionen i filen

SEEK_END : ställer in offset för att förskjuta byte från slutet av filen

Om pekaren har installerats, returnerar funktionen fseek() 0, och om pekaren misslyckas returnerar den -1.

Exempel på användning av funktionen:

$fd = fopen("hej.txt", "w+") eller die("kunde inte öppna filen"); $str = "Hej värld!"; // rad för att skriva fwrite($fd, $str); // skriv raden till början fseek($fd, 0); // placera filpekaren i början fwrite($fd, "Oink"); // skriv raden i början fseek($fd, 0, SEEK_END); // placera pekaren i slutet fwrite($fd, $str); // skriv ytterligare en rad i slutet fclose($fd);

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 språkmotto, "Det finns mer än ett sätt att göra något", speciellt när vi pratar om om 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 du gör standardförfarande, använd 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 argument till fgets för att begränsa maximal längd rader av fångad data. 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 allt det hittar. HTML-taggar eller PHP, 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 bitar 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 det detta kommando sammanslagna sektioner. 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 att få mer detaljerad information om hur dessa funktioner fungerar. Båda är värda att överväga om du jobbar med dessa typer av filer, men istället för att titta på alla möjliga filtyper kanske du vill ta en närmare titt på innehållet i denna artikel, där det finns flera bra generella regler för att arbeta 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 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 om 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 programvara, använd dem mest effektivt och ha kul att bearbeta dina filer med PHP.

PHP dök upp mycket senare än att programmeringsspråk stärkte sina positioner och formulerade allmänna idéer om syntax, logik, variabler och andra programobjekt. Filer och funktioner för att arbeta med dem gjorde inga framsteg, och inte ens problemet med filkodning, som uppstod av naturliga skäl, ledde inte till radikalt nya lösningar.

Allmänna kommentarer

Huvudarbetet med filer, vad de än är, består av att öppna, läsa/skriva och stänga. Du kan använda funktionerna för att blockera/avblockera åtkomst till en fil medan den bearbetas, du kan ställa in läs/skrivpositionen i filen - allt är som tidigare, i det avlägsna förflutna.

En viktig punkt i PHP är överflöd av funktioner för att arbeta med filer och alternativ för att använda dem. I praktiken räcker det att använda enkla men fungerande alternativ. En fil är först och främst ett programminne. Du kan lagra information i den. Syftet med alla program, syftet med någon webbplats är att presentera, bearbeta och säkerställa informationens säkerhet.

Väsentlig omständighet

Tidigare var kravet på kompatibilitet, åtminstone från botten till toppen, orubbligt. Det vill säga att ett program som en gång skrivits i en version av ett programmeringsspråk helst kompileras/tolkas i nästa version. I modern programmering är detta inte fallet. Kravet på kompatibilitet av syntaktiska strukturer i ett språk har blivit en historia, och kampen mellan stilar och programmeringsverktyg och versioner av vissa verktyg har blivit normen i deras liv.

Att arbeta med filer, såväl som med databaser, är lika viktigt som webbplatsens gränssnitt. Den första bör byggas på ett sådant sätt att när du byter plattform, värd eller språkversion behöver du inte ändra webbplatskoden. Gränssnittet för att arbeta med filer måste ingå i ett separat skript och säkerställa full kompatibilitet, precis som webbplatsens design måste anpassas till alla enheter, webbläsare och ge resten av webbplatsens funktionalitet med samma möjligheter.

Läs och förändra dig själv

Kan ett program ändra sig självt, det vill säga kan ett manus förbättras? Än idag intresserar denna fråga många. Men uppgiften låter mycket mer praktisk: PHP läser en PHP-fil. En utvecklare kan inte alltid lösa ett visst problem genom att skriva specifik kod. Ibland är det nödvändigt att ändra det när en besökare kommer till sajten och formulerar en fråga som inte förutsågs i utvecklingsstadiet.

Som i alla andra fall måste du först och främst öppna filen. Det spelar ingen roll om den här filen finns eller inte. Om det är känt att filen finns (funktionen file_exists() ger ett positivt svar), används fopen()-funktionen med åtkomst 'r', 'r+', 'a', 'a+'. Om filen inte finns ännu, med åtkomst 'a', 'a+', 'w', 'w+'. Resultatet av att öppna en fil blir dess deskriptor. Filen stängs med funktionen fclose().

Det är bekvämt att använda PHP för att läsa in en fil i en array när det inte finns något behov av att bearbeta den vid läsningen.

if (fil_exists($fName)) (

$aLines = fil($fName)

I det här alternativet går varje rad i filen in i arrayelementet sekventiellt. Det bör noteras att funktionerna file() eller file_get_contents() inte behöver öppna filen och stänga den.

När indatafilen är för stor och du bara behöver hitta lite information, eller av andra skäl kan du använda PHP för att läsa filen rad för rad. PHP ger möjligheten att göra detta med funktionerna fgets() och fgetc().

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

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

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

Båda alternativen fungerar felfritt. Men när du utför PHP-läsning av en PHP-fil för senare modifiering bör försiktighetsåtgärder vidtas. Det är inte alltid möjligt att förutse hur en besökare kommer att använda den i utvecklingsstadiet. Det är bättre om skripten ändras inom webbplatsens funktioner, och kontroll över denna ändring är inte tillgänglig för besökaren, inklusive resursadministratören.

Sparar resultat

Den mottagna och uppdaterade informationen skrivs till filen av funktionen fputs() rad för rad eller av funktionen file_put_contents() som helhet.

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

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

flock($fvs, LOCK_EX)

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

fputs($fvs, $cLine)

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

fputs($fvs, $cLine)

flock($fvs, LOCK_UN)

I inspelningsalternativet rad för rad kan du manipulera data under inspelningsprocessen, i det andra fallet placeras den skrivna strängen eller matrisen i hela filen.

$fil = " scData.php "

$cContents = file_get_contents($file)

// lägga till en post

$cContents .= "ny post\n"

// skriv tillbaka filen

file_put_contents($file, $cContents)

Att läsa och skriva PHP-filer är enkelt och naturligt. Det är dock viktigt att tänka på: varje fil har ett namn, filtillägg och sökväg (mapp). För att ett PHP-skript ska kunna läsa och skriva filer måste detta skript ha lämpliga rättigheter. De exponeras automatiskt på webbhotellet, men i vissa fall behöver de utökas.

I vissa fall kan det vara önskvärt att verifiera resultaten genom att utföra en testavläsning. Att skriva PHP-filer kräver detta under utvecklingen, men i vissa fall är det viktigt att kontrollera dataregistreringen för att säkerställa webbplatsens säkerhet eller tillförlitlighet.

En karakteristisk egenskap hos PHP, MySQl, JavaScript och särskilt webbläsare: tyst tillåter vissa fel att hända. "Inte erkänd, inte gjort..." - inte en särskilt bra frontlinjepraxis informationsteknik, men detta lär utvecklare att inte göra misstag och skriva ren kod av hög kvalitet, vilket inte heller är dåligt.

PHP och arbeta med riktiga dokument

PHP att läsa en PHP-fil är verkligen av praktiskt intresse, men detta är programmeringsområdet. Användaren och webbplatsbesökaren är intresserad av information av tillämpad karaktär, som han är van att se i form av tabeller och dokument, i synnerhet i filformaten *.xlsx och *.docx. Dessa är filer i MS Excel- och MS Word-format.

Listor över varor, priser, egenskaper bildas vanligtvis i form av tabeller, så PHP-läsning av Excel-filen är viktigt.

PHPExcel- och PHPWord-biblioteken har utvecklats för att fungera med sådana filer. Innehållet i *.xlsx- och *.docx-filerna presenteras dock i OOXML-standarden, det vill säga det verkliga, begripliga dokumentet presenteras i ett zip-arkiv. Ett Zip-arkiv är en uppsättning filer, inklusive bilder, objekt, formler och inlägg från andra program. Textfiler här representeras av beskrivningar i form av taggar. Det räcker inte att läsa en sådan fil, du måste analysera den för att få innehållet och strukturen för användning och modifiering.

Detta innebär att läsoperationen övergår i ett arkivöppningsförfarande. Dessa bibliotek öppnar dokumentarkivet självständigt och ger utvecklaren omfattande funktioner för att läsa, bearbeta och skriva sådana dokument.

Excel-tabeller

include_once 'PhpOffice/PhpExcel/IOFactory.php'

funktion scGetExcelFile($xls)(

$objPHPExcel = PHPExcel_IOFactory::load($xls)

$objPHPExcel->setActiveSheetIndex(0)

//denna array innehåller arrayer av strängar

$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)

Att läsa och bearbeta Excel-filer är mycket svårare att bearbeta Word-dokument. Det bästa alternativet, om du behöver implementera ett seriöst projekt för att läsa och bearbeta tillämpad information, är att först behärska PHPWord-biblioteket. Detta kommer att ge dig god erfarenhet och en snabb förståelse av detaljerna i problemet.

Word-dokument

Bara två rader:

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

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

$cFileName-dokumentet är nu tillgängligt för bearbetning. Därefter öppnas arkivet, dess innehåll väljs ut och analyseras, vilket kan visas på hemsidan, ändras och skrivas tillbaka.

$zipClass = new ZipArchive()

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

// läs hela innehållet i dokumentet

för ($i=0; $i<$zipClass->numFiles; $i++) (

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

$cNameInExt = substr($cNameIn, -4)

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

// filer med tilläggen ".xml" och ".xml.rels" sparas i dokumenttabellen

// varje xml-rad skrivs med ett unikt nummer i ordning

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

$cBodyInLen = strlen($cBodyIn)

// alla andra filer skrivs till dokumentmappen som de är

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

$zipClass->getFromName($cNameIn, $cWorkPath); // innehåll som en fil

Möjligheterna som öppnar sig när PHP hjälp Excel och PHP Word låter dig manipulera verkliga dokument och göra deras innehåll relevant när som helst. I dagens dynamiska värld blir detta väldigt viktigt. Tyngdpunkten har sedan länge passerat från lokal användning datorutrustning in i det virtuella internetutrymmet. Därför är det mindre effektivt att skapa tabeller och dokument i lokala Microsoft-produkter än att arbeta med sådana dokument i automatiskt och halvautomatiskt läge på en webbplats, som är tillgänglig inte bara för skaparen av tabellen eller dokumentet, utan också för dess konsumenter.

Textfiler, ett annat liv

Till en första uppskattning är textfiler enklare än PHP-filer eller applikationsdokument. Det finns dock något att tänka på här. Läs-/skrivoperationerna för sådana filer är redan indikerade ovan, men innebörden av sådana filer är mycket viktigare.

Eftersom det finns en given som en klient och en server (den första domineras av JavaScript, den andra av PHP), kan inte ens cookie- och sessionsmekanismerna klara av behovet av att överföra information mellan skript, sidor eller vissa processer.

Det är möjligt att spegla de önskade förändringarna i databasen, men för alla deras fördelar och hastighet kan små temporära eller permanenta textfiler vara ett mycket mer intressant alternativ för att överföra information. Om du inte skapar många små filer och kontrollerar deras storlek kan de vara en specifik och mer flexibel version av en databas.

PHP att läsa en textfil går snabbt, den kan omedelbart tolkas till en struktur, array eller objekt. Det senare är mycket viktigt, eftersom det låter dig skapa objekt som lever utanför den tilldelade tiden PHP-skript, som, som ni vet, bara kan existera på servern och endast vid den tidpunkt då sidan laddas genereras ett AJAX-svar, eller av annan anledning som gör att PHP-tolken startar.

Om du tänker på det faktum att en textfil är innehållet och strukturen från utvecklaren, är en PHP-fil syntaxen för tolken plus utvecklarens logik, och "taggade" beskrivningar html, css, xml är mer semantiska element, men reglerade enligt statiska standarder. Man kan komma till slutsatsen att det förmodligen är dags för filerna att skaffa nytt innehåll, och detta bör i sig avgöra deras kvalitet och användningslogik. Det är just för att programmering ännu inte är redo för nästa steg i dess utveckling som filer idag förblir helt enkelt filer som utvecklaren skapar och bestämmer hur de ska användas.

Det mest intressanta och lovande är när PHP läser en PHP-fil självständigt när behovet uppstår. Och en enkel PHP-läsning av en rad från en fil resulterar i att ett objekt skapas, åtminstone i det tillstånd som det sparades i. Det är inte helt bekanta idéer, men i den moderna världen förändras allt så snabbt.

16,5 000

Faktum är att hur man öppnar en php-fil är inte ett stort problem. Det kan vara svårare att öppna en flaska öl när du är mitt i en skog. Men bara inbitna programmerare tänker så här. Och för nybörjare kommer vi att berätta om alla funktioner i PHP för att arbeta med filer:

php-filer

Filer med filtillägget php innehåller kod skriven i programmeringsspråket med samma namn. Till skillnad från andra språk är php ett programmeringsspråk på serversidan. Det vill säga att den körs på serversidan. För att felsöka dess kod måste därför en lokal server installeras på klientdatorn.

För att arbeta med php-filer används speciella applikationer - programvaruredigerare. De vanligaste är:

• Dreamweaver.
• PHPEdit.
• Eclipse PHP-utveckling.

När du skapar webbplatser baserade på PHP kan du behöva återanvända programkoden. I sådana situationer är det bekvämt att ansluta färdiga lösningar som finns i en annan fil. Inkludera-konstruktionen används för detta. Dess syntax är:

inkludera filnamn

Exempel på anslutning:

Inkluderad fil:

Det är också möjligt att inkludera en fil med konstruktionen require. Till skillnad från include inkluderar den filen innan programkoden körs. Genom att använda require i koden är endast ett anrop till denna fil möjligt. När det öppnas igen kommer systemet att visa ett globalt felmeddelande och stoppa programkörningen.

Inkludera-konstruktionen inkluderar endast källan under programkörning. Den stöder flera läsningar av php-filer. Om ett fel uppstår kommer endast ett varningsmeddelande att visas och kodexekveringen fortsätter från nästa rad.

Öppna och stänga filer

I php utförs alla operationer med filer i flera steg:

• Öppna en fil;
• Innehållsredigering;
• Stänger filen.

Funktionen fopen() används för att öppna en fil. Dess syntax är:

int fopen(sträng filnamn, strängläge [, int use_include_path])

Godkända argument:

• sträng filnamn – filnamn eller absolut sökväg till den. Om sökvägen till filen inte anges, kommer den att sökas i den aktuella katalogen. Om filen du letar efter saknas visar systemet ett felmeddelande. Exempel:

• strängläge – indikerar filöppningsläget. Värden som accepteras av argumentet:

• r – filen öppnas endast för läsning, filpekaren är inställd i början;
• r+ – filen är öppen för läsning och skrivning;
• w – skapar en ny fil endast för skrivning. Om en fil med samma namn redan finns raderas all data i den automatiskt;
• w+ - skapar en ny fil för att skriva och läsa. När en sådan fil existerar skrivs dess data helt över med nya;
• a – filen är öppen för skrivning. Pekaren sätts i slutet. Det vill säga, att skriva till php-filen börjar inte från början utan från slutet;
• a+ – öppna en fil i läs-skrivläge. Inspelningen börjar från slutet;
• b – arbetssätt med en fil som innehåller binära data (i det binära talsystemet). Detta läge är endast tillgängligt i operativ system Windows.

För att stänga åtkomsten till en fil, använd fclose()-funktionen. Syntax:

int fclose (int-fil) , där int-fil är ett handtag till platsen som ska stängas.

Efter varje läsning eller skrivning måste filen stängas med denna funktion. Annars förblir strömmen som skapats för filen öppen. Och detta leder till onödig förbrukning av serverkapacitet.

Exempel:

Läsa och skriva filer

För att helt enkelt visa hela innehållet i en fil är funktionen readfile() idealisk. Dess syntax är:

readfile (strängfilnamn) , där strängfilnamn är strängfilnamnet (inte ett handtag).

Samma fil kan läsas med funktionen fpassthru() . Den läser data från slutpekarens position till slutet av filen. Dess syntax är:

int fpassthru (int-fil)

Funktionen kräver att en fil öppnas och stängs. Exempel:

Resultatet liknar det föregående.

Funktioner för att arbeta med filer i php låter dig läsa innehåll rad för rad och tecken för tecken:

• sträng fgets (int-fil, int-längd)– funktionen läser en sträng med längdlängd . Exempel:

• string fread (int-fil, int-längd)– åtgärden är identisk med den föregående.

För att skriva textdata till en fil finns det två identiska funktioner:

• int fputs (int-fil, strängsträng [, int längd ])
• int fwrite(int fil, strängsträng [, int längd ])

Funktionerna skriver till en fil int-fil en strängsträng med angiven längd int längd ( valfritt argument). Exempel:

Skapa och ta bort filer

För att skapa en php-fil kan du använda fopen()-funktionen i "w" eller "w+" åtkomstläge. Eller touch()-funktionen. Den ställer in filändringstiden. Om det inte finns något element med det sökta namnet skapas det. Dess syntax.