Hur man arbetar med PHP och FTP

Koda

I denna handledning är vårt mål att skapa en FTP-klass med PHP som är välskriven, användbar och utvidbar.

Beskriver vårt mål

Det är alltid viktigt att först beskriva exakt vilken funktionalitet din klass ska innehålla. I vårat fall:

anslutning till en server
skapa en mapp på servern
ladda upp en fil
ändra katalog
hämtar kataloglistan
ladda ner en fil

När skulle jag använda en FTP-klass?

Det finns flera fall när man kan använda den här typen av klass. Ett par scenarier kan vara:

Automatisera uppladdning av bilder, till exempel ett galleri, till en kunds webbplats (helst i samband med min bildändringsformat)
Utför säkerhetskopior på platsen genom att överföra en databas backup fil från din server till en annan. (Obs! Det här rekommenderas inte för känslig information eftersom FTP inte är ett mycket säkert protokoll.)

Notera: Det är lätt att köra in i problem med FTP på grund av olika serverkonfigurationer. Denna kod har testats på ett antal FTP-servrar framgångsrikt.

Vad är FTP?

FTP: "Ett standardnätverksprotokoll som används för att kopiera en fil från en värd till en annan."

FTP, eller File Transfer Protocol, definieras av Wikipedia: "Ett standardnätverksprotokoll som används för att kopiera en fil från en värd till en annan via ett TCP / IP-baserat nätverk, till exempel Internet."

I huvudsak kan du kopiera en fil från en dator till en annan.

Steg 1 - Framställning

Vi börjar så enkelt som möjligt. Skapa i ditt nya projekt rot två filer: index.php och ftp_class.php.

De index.php filen är vår huvudsida som skapar objektet och kallar nödvändiga metoder. De ftp_class.php är just det: vår ftp-klass.

I nästa steg ska vi skapa skelettet för vår klass. När detta är på plats kan du följa med och försöka varje steg.

Steg 2 - Konfigurera klassen

Styrkan hos Objektorienterad Programmering (OOP) är att ge komplex kod en enkel att använda gränssnitt. Genom att skapa en klass - tänk på en klass som ett mönster - kan du inkapsla data, vilket helt enkelt är jargong för en term som avser att dölja data. Vi kan sedan återanvända denna klass om och om igen utan att behöva skriva om någon kod. Istället behöver du bara kalla lämpliga metoder (termen "metod" är det samma som fungera).

Låt oss börja skapa vår ftp-klass. Öppna din ftp_class.php fil och lägg till följande kod. Detta är en grundläggande klassskelettstruktur, som jag har namngivit "FTPClient'.

De konstruera funktion, som kallas en konstruktör, är en specialklassmetod som automatiskt kallas av klassen när du skapar ett nytt objekt, eller en förekomst av klassen. Det här är vanligtvis ett bra ställe att lägga till lite initialisering; men för dagens syfte behöver vi inte det. Vi kommer ändå att behålla det här för framtida användning.

 Klass FTPClient // *** Klassvariabler offentlig funktion __construct ()

Observera att vi använder en dubbel understrykning för det konstruera metod.

Steg 3 - Klassvariabler

Därefter ställer vi in några klassvariabler eller egenskaper.

 privat $ connectionId; privat $ loginOk = false; privat $ messageArray = array ();

"privat"prefix definierar variabelns räckvidd. I det här fallet betyder det att variabeln inte kan nås från var som helst utanför klassen.

De $ connectionID variabel lagrar vår anslutningsström. De andra två lagrar status och eventuella meddelanden. $ loginOk kommer att vara användbart när du bestämmer om vi är korrekt anslutna.

Steg 4 - Enkelt meddelandehantering

I nästan alla metoder kommer vi att ringa en metod som heter "logMessage. Det här är en mycket grundläggande meddelandehanterare som tillåter oss att fånga alla meddelanden som skapats av vår klass så att vi kan ge användaren feedback.

Observera att vi inte gör det lämna tillbaka de faktiska meddelandena från våra metoder. I stället återkommer vi Sann eller falsk, baserat på huruvida en viss operation var framgångsrik eller inte. Detta har sina fördelar, men beskriver inte heller användaren vad som händer.

Lägg till följande två metoder, så vi kan bestämma vad som är framgångsrikt.

Denna metod accepterar en variabel, $ message. Innehållet i denna variabel sparas sedan i vår klassmatris tack vare linjen: $ this-> messageArray [] = $ message;

 privat funktion logMessage ($ message) $ this-> messageArray [] = $ message;

Därför att $ messageArray är en klassvariabel, vi kan komma åt det via $ This-> notation.

Inom en klass, $ detta hänvisar till själva objektet.

För att hämta meddelandet ringer vi getMessages.

 public function getMessages () return $ this-> messageArray;

Denna metod är en offentlig metod. Som nämnts tidigare hänvisar denna privata / offentliga verksamhet helt enkelt till variabelns omfattning, eller i det här fallmetoden. En privat metod (eller variabel) kan inte nås utanför klassen, medan en offentlig metod (eller variabel) kan.

Eftersom vår variabel är privat behöver vi ett sätt att komma åt det. Vi gör det genom att ge vår klass a offentlig metod, som vi då kan komma åt utanför klassen. Du kanske undrar varför vi inte bara kan göra messageArray variabel allmänhet. Vi kan; det sagt, det är bara inte en bra övning.

Notera: Det finns många exempel på webben av fullblåsta meddelandehanterare eller klasser som är dedikerade till dem. Vi arbetar med en enkel implementering för syftet med denna handledning.

Steg 5 - Anslutning

I detta steg lägger vi till ansluta metod. Detta gör det möjligt för oss att ansluta till en FTP-server.

 public function connect ($ server, $ ftpUser, $ ftpPassword, $ isPassive = false) // *** Ställ in grundläggande anslutning $ this-> connectionId = ftp_connect ($ server); // *** Logga in med användarnamn och lösenord $ loginResult = ftp_login ($ this-> connectionId, $ ftpUser, $ ftpPassword); // *** Sätter passivt läge på / av (standardavstängning) ftp_pasv ($ this-> connectionId, $ isPassive); // *** Kontrollera anslutningen om ((! $ This-> connectionId) || (! $ LoginResult)) $ this-> logMessage ('FTP-anslutningen har misslyckats!'); $ this-> logMessage ('Försök att ansluta till'. $ server. 'för användare'. $ ftpUser, true); returnera false;  else $ this-> logMessage ('Connected to'. $ server. ', för användare'. $ ftpUser); $ this-> loginOk = true; återvänd sant;

Vi skickar i vår anslutningsinformation: servern ($ server), Användarnamn ($ ftpUser) och lösenord ($ ftpPassword) för att tillåta oss att upprätta en anslutning.

Den första raden av kod öppnar en FTP-anslutning, med ftp_connect, till den angivna servern. Vi sparar vår anslutning till klassvariabeln, $ connectionID beskrivet ovan.

Koden, ftp_login loggar in oss till den angivna anslutningen, passerar i vår anslutnings-id, vårt användarnamn och lösenord.

Du kanske har märkt det ftp_pasv kodlinje. Detta, som kommentaren innebär, slår på / av passivt läge. Jag föreslår att du lämnar den av, men om du har problem med att ansluta, försök att slå på den. Passivt läge kan orsaka lite av en hoppare vid anslutning via FTP.

Vi avgör om anslutningen lyckades. Vi loggar sedan resultaten genom att ringa vår enkla meddelandehanteringsmetod, logMessage (), och passera strängen för att logga. Kom ihåg: vi använder $ This-> få tillgång till logMessage (), eftersom det är en klassvariabel.

Steg 6 - Ringa objektet

Nu när vår klass arbetar, kan vi testa det! Öppna din index.php fil och lägg till följande kod.

Du behöver tillgång till en FTP-server för att kunna spela tillsammans. Om du vill ställa in din egen server, försök Filezilla - det är gratis också.

Du kommer märka att jag har lagt till FTP-serverns detaljer här. Idealiskt skulle dessa lagras inom din config fil. Ändra dessa för att matcha inställningarna för din FTP-server.

Efter att vi har definierat våra FTP-server detaljer, ingår vi i klassen med innefattar ( 'ftp_class.php');. Det innebär att göra klassen tillgänglig från den här sidan. Nästa rad skapar ett objekt i vår FTP-klass och lagrar den i variabeln, $ ftpObj. $ ftpObj kommer nu att användas för att få tillgång till alla offentliga metoder inom vår klass. Detta görs genom att använda -> notation, precis som följande rad gör genom att ringa $ ftpObj -> anslut metod och skickar det till våra serveruppgifter.

 // *** Definiera ditt värd, användarnamn och lösenord definiera ('FTP_HOST', '192.168.1.88'); definiera ('FTP_USER', 'Blimpf'); definiera ('FTP_PASS', 'havskatt'); // *** Inkludera klassen inkluderar ('ftp_class.php'); // *** Skapa FTP-objektet $ ftpObj = nytt FTPClient (); // *** Anslut $ ftpObj -> anslut (FTP_HOST, FTP_USER, FTP_PASS);

Som du kan se, när vår klass är på plats, är det verkligen ganska lätt att ansluta till vår FTP-server!

Steg 6b - Visa utmatningen

I det sista steget kunde vi koppla samman samtalet i en om uttalande, vilket visas nedan. Då, om vi misslyckas med att ansluta, kommer den beroende koden inte att utföras. Vi kan sedan mata ut några meddelanden till användaren, till exempel "ansluten" eller "misslyckad".

 // *** Anslut om ($ ftpObj -> anslut (FTP_HOST, FTP_USER, FTP_PASS)) // *** Lägg sedan till FTP-kod här echo 'connected';  else echo 'Misslyckades att ansluta';

Det här är okej, men vår kod kommer snabbt att bli ganska uppblåst med IF / ELSE-uttalanden, om vi lägger till detta på alla våra samtal. I stället vill jag erbjuda ett alternativ som gör sakerna lite renare och enklare att följa.

Kommer du ihåg de hanteringsmetoder vi lagt till? Om du vill se de meddelanden som produceras av klassen - som är till hjälp för debugging / feedback - kan du lägga till följande kod efter vilken metod som du ringer.

 print_r ($ ftpObj -> getMessages ());

Detta kommer att visa klassmeddelandet.

Steg 7 - Gör vårt första katalog

Utmärkt, nu är det dags att göra något användbart. Den första metoden vi ska skapa är MakeDir metod. Som förväntat kommer denna metod att skapa kataloger för oss på servern. Den enda parametern vi ska passera är katalogvägen och mappnamnet; vi ringer det $ katalog. Den magiska linjen här är ftp_mkdir inbyggd funktion. Det använder vår sparade "connectionID"och de passerade in $ katalog variabel för att skapa mappen.

Lägg till följande kod till din ftp_class.php fil:

 public function makeDir ($ directory) // *** Om du skapar en katalog lyckas? om (ftp_mkdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Directory' '. $ directory.' "Skapad framgångsrikt"); återvänd sant;  annars // ***? Annars, FEL. $ this-> logMessage ('Misslyckades med att skapa katalog' '. $ directory.' "'); returnera false;

Och att ringa det från din index.php fil, lägg till:

 $ dir = 'photos'; // *** Gör katalogen $ ftpObj-> makeDir ($ dir);

Variabeln, $ dir är inställd på namnet på den mapp vi vill skapa på servern. I detta fall: "foton".

Nästa rad anropar metoden som skapar mappen.

Om du får ett "Tillstånd nekat" -fel, se till att du kan skriva i den angivna mappen. Du kan behöva skapa mappen i en katalog, till exempel / httpdocs.

Steg 8 - Ladda upp en fil

Fortsätt på, låt oss ladda upp ett foto som heter zoe.jpg. När du laddar upp en fil måste vi ange vilken typ av fil vi laddar upp - binär eller ascii? I grund och botten, om du laddar upp en textfil, borde vi använda den ascii; annars bör den vara inställd på binär.

Vi börjar med att skapa en array med alla de förlängningar som vi ska använda för en ascii skriv uppladdning.

 $ asciiArray = array ('txt', 'csv');

Sedan hämtar vi filens förlängning, så vi kan testa om det är en av ascii typer. Vi bestämmer detta genom att få förlängningen av filen vi laddar upp. Den snabba och smutsiga metoden som jag har använt här är
genom att "explodera" filen genom att använda "."som avgränsare. Detta delar upp filen i bitar och lagras som en array. Med hjälp av en annan inbyggd PHP-funktion, "slut", väljer vi den sista array element som innehåller vår förlängning. Det är en snygg liten kod.

 $ extension = end (explodera ('.', $ fileFrom));

Därefter testar vi om vår tillägg visas i listan (med in_array) av filtillägg som ska laddas upp som typ ascii. Om det visas i listan ställer vi in variabeln $ -funktion till FTP_ASCII; Annars antar vi att det är av binär typ och tilldela $ -funktion värdet FTP_BINARY.

 in_array ($ extension, $ asciiArray)

ftp_put laddar upp en fil från din lokala plats till en fjärrfil på ftp-servern. Vi skickar det till vår "connectionID", sökvägen till filen vi vill ladda upp till ($ fileTo), vägen
av filen vi vill ladda upp ($ fileFrom) och läget ($ -funktion) som vi just har bestämt.

Lägg sedan till följande metod för din ftp_class.php fil:

 public function uploadFile ($ fileFrom, $ fileTo) // *** Ställ in överföringsläget $ asciiArray = array ('txt', 'csv'); $ extension = end (explodera ('.', $ fileFrom)); om (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII;  annat $ mode = FTP_BINARY;  // *** Ladda upp filen $ upload = ftp_put ($ this-> connectionId, $ fileTo, $ fileFrom, $ mode); // *** Kontrollera upload status om (! $ Upload) $ this-> logMessage ('FTP uppladdning har misslyckats!'); returnera false;  else $ this-> logMessage ('Uploaded' '. $ fileFrom.' "som" '. $ fileTo); returnera true;

Visst kan du skapa eller ladda upp ett mappnamn du önskar! Lägg till den här nästa kodbiten till din index.php fil och justera därefter.

 $ fileFrom = 'zoe.jpg'; $ fileTo = $ dir. '/'. $ FileFrom; // *** Ladda upp lokal fil till ny katalog på server $ ftpObj -> uploadFile ($ fileFrom, $ fileTo);

Nu borde du komma överens med hur lätt den här klassen är att använda! Vi gör bara enskilda samtal för att utföra våra uppgifter - allt tack vare objektorienterad programmering!

Steg 9 - Visa filerna

Låt oss nu bekräfta att vår fil finns i Foto mapp. Det kan vi göra genom att navigera till "Foto'mapp på vår server och visa sedan innehållet.

De changeDir metodanvändning "ftp_chdir"för att ändra den aktuella katalogen på ftp-servern. Håll bara i katalogen för att byta till. Enkel och söt.

ftp_class.php:

 public function changeDir ($ katalog) if (ftp_chdir ($ this-> connectionId, $ directory)) $ this-> logMessage ('Aktuell katalog är nu:'. ftp_pwd ($ this-> connectionId)); återvänd sant;  else $ this-> logMessage ('Couldn \' t ändra katalogen '); returnera false;

getDirListing kommer att visa innehållet i katalogen du befinner dig i med funktionen "ftp_nlist". Den här funktionen returnerar en lista med filer i en viss katalog. Den aktuella katalogen är som standard, så du behöver inte ange några parametrar.

Om du önskar kan du åsidosätta detta genom att passera i $ katalog sökväg du vill se innehållet i. De $ parametrar variabla standardvärden till "-la'. Detta är ett Linux-kommando för att visa mer information om katalogen. Ta gärna bort det eller skicka det i en tom sträng.

ftp_class.php:

 offentlig funktion getDirListing ($ directory = '.', $ parameters = '-la') // hämta innehåll i den aktuella katalogen $ contentArray = ftp_nlist ($ this-> connectionId, $ parameters. contentArray;

De getDirListing Metoden returnerar en array som innehåller vår katalognotering.

index.php

// *** Ändra till mapp $ ftpObj-> changeDir ($ dir); // *** Hämta mappinnehåll $ contentArray = $ ftpObj-> getDirListing (); // *** Utmatar vårt utbud av mappinnehåll echo "

'; print_r ($ contentsArray); eko "

Ditt resultat ska se ut så här:

Steg 10 - Ladda ner en fil

När vi trycker mot slutet av denna handledning fortsätter vi med att ladda ner filen. Metoden börjar med samma kod som ladda upp fil, genom att det bestämmer om filen vi vill hämta är ascii eller binär.

För den här metoden passerar du helt enkelt i filnamnet (och eventuellt sökvägen beroende på om du är i samma mapp som filen du vill ladda ner) av filen som ska hämtas och namnet du vill ha den filen på din klient maskin.

För att ladda ner en fil måste du ringa ftp_get.

 ftp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ läge, 0)

Detta hämtar en fil från en fjärrserver till vår lokala maskin. Den accepterar följande parameter: vårt anslutnings-id, sökvägen och filnamnet för att spara som lokalt (kommer att skrivas över om det
existerar redan) ($ fileTo), plats och namn på filen på fjärrservern ($ fileFrom) och läget ($ -funktion).

ftp_class.php

 allmän funktion downloadFile ($ fileFrom, $ fileTo) // *** Ställ överföringsläget $ asciiArray = array ('txt', 'csv'); $ extension = end (explodera ('.', $ fileFrom)); om (in_array ($ extension, $ asciiArray)) $ mode = FTP_ASCII;  annat $ mode = FTP_BINARY;  // försök ladda ner $ remote_file och spara det till $ hantera om (ftp_get ($ this-> connectionId, $ fileTo, $ fileFrom, $ läge, 0)) return true; $ this-> logMessage ('file' '. $ fileTo.' "framgångsrikt nedladdad");  annars return false; $ this-> logMessage ('Det fanns ett fel att ladda ner filen' '. $ fileFrom.' "till" '. $ fileTo.' "');

Vi laddar ner samma fil som vi laddat upp genom att spara den med ett annat namn på vår klientmaskin.

Notera: Återigen, se till att dina behörigheter är rätt inställda!

För att vi nu borde vara inne i vårt Foto mapp, lägger vi inte till en sökväg till $ fileFrom variabel - bara filnamnet.

index.php

 $ fileFrom = 'zoe.jpg'; # Plats på servern $ fileTo = 'zoe-new.jpg'; # Lokal dir att spara till // *** Hämta fil $ ftpObj-> downloadFile ($ fileFrom, $ fileTo);

Steg 11 - Efterbehandling

För att slutföra vår klass, låt oss lägga till klassens magiska metod, __deconstruct. Den här metoden stänger vår anslutning när hänvisningen till vårt objekt inte längre existerar - kanske sidan stängdes. Under alla omständigheter körs den här koden och anslutningen är stängd. Det är alltid en bra praxis att inkludera detta, men det är inte helt nödvändigt.

 offentlig funktion __deconstruct () if ($ this-> connectionId) ftp_close ($ this-> connectionId);

Slutsats

Jo det gör det! Jag hoppas att du nu har en bättre förståelse för hur du använder FTP med PHP. Du bör nu ha nödvändiga färdigheter för att ytterligare utöka den här klassen för att stödja andra vanliga uppgifter, till exempel byta namn på eller radera filer och mappar.

Var noga med att meddela om du skapar några coola PHP FTP-klienter!

Koda